0010790c : #include static void CPU_usage_Per_thread_handler( Thread_Control *the_thread ) { 10790c: 55 push %ebp <== NOT EXECUTED 10790d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10790f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS the_thread->cpu_time_used.tv_sec = 0; 107912: c7 80 84 00 00 00 00 movl $0x0,0x84(%eax) <== NOT EXECUTED 107919: 00 00 00 <== NOT EXECUTED the_thread->cpu_time_used.tv_nsec = 0; 10791c: c7 80 88 00 00 00 00 movl $0x0,0x88(%eax) <== NOT EXECUTED 107923: 00 00 00 <== NOT EXECUTED #else the_thread->cpu_time_used = 0; #endif } 107926: c9 leave <== NOT EXECUTED 107927: c3 ret <== NOT EXECUTED 0010d8a0 : #define MAXSYMLINK 5 int IMFS_Set_handlers( rtems_filesystem_location_info_t *loc ) { 10d8a0: 55 push %ebp <== NOT EXECUTED 10d8a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d8a3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED IMFS_jnode_t *node = loc->node_access; IMFS_fs_info_t *fs_info; fs_info = loc->mt_entry->fs_info; 10d8a6: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10d8a9: 8b 48 2c mov 0x2c(%eax),%ecx <== NOT EXECUTED switch( node->type ) { 10d8ac: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10d8ae: 83 78 4c 06 cmpl $0x6,0x4c(%eax) <== NOT EXECUTED 10d8b2: 77 12 ja 10d8c6 <== NOT EXECUTED 10d8b4: 8b 40 4c mov 0x4c(%eax),%eax <== NOT EXECUTED 10d8b7: ff 24 85 c0 93 11 00 jmp *0x1193c0(,%eax,4) <== NOT EXECUTED 10d8be: 66 90 xchg %ax,%ax <== NOT EXECUTED case IMFS_DIRECTORY: loc->handlers = fs_info->directory_handlers; 10d8c0: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10d8c3: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED loc->handlers = fs_info->memfile_handlers; break; } return 0; } 10d8c6: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d8c8: c9 leave <== NOT EXECUTED 10d8c9: c3 ret <== NOT EXECUTED 10d8ca: 66 90 xchg %ax,%ax <== NOT EXECUTED break; case IMFS_LINEAR_FILE: loc->handlers = fs_info->memfile_handlers; break; case IMFS_MEMORY_FILE: loc->handlers = fs_info->memfile_handlers; 10d8cc: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d8cf: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED break; } return 0; } 10d8d2: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d8d4: c9 leave <== NOT EXECUTED 10d8d5: c3 ret <== NOT EXECUTED 10d8d6: 66 90 xchg %ax,%ax <== NOT EXECUTED case IMFS_DEVICE: loc->handlers = &IMFS_device_handlers; break; case IMFS_SYM_LINK: case IMFS_HARD_LINK: loc->handlers = &IMFS_link_handlers; 10d8d8: c7 42 04 a0 94 11 00 movl $0x1194a0,0x4(%edx) <== NOT EXECUTED loc->handlers = fs_info->memfile_handlers; break; } return 0; } 10d8df: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d8e1: c9 leave <== NOT EXECUTED 10d8e2: c3 ret <== NOT EXECUTED 10d8e3: 90 nop <== NOT EXECUTED switch( node->type ) { case IMFS_DIRECTORY: loc->handlers = fs_info->directory_handlers; break; case IMFS_DEVICE: loc->handlers = &IMFS_device_handlers; 10d8e4: c7 42 04 60 94 11 00 movl $0x119460,0x4(%edx) <== NOT EXECUTED loc->handlers = fs_info->memfile_handlers; break; } return 0; } 10d8eb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d8ed: c9 leave <== NOT EXECUTED 10d8ee: c3 ret <== NOT EXECUTED 00122670 : int IMFS_chown( rtems_filesystem_location_info_t *pathloc, /* IN */ uid_t owner, /* IN */ gid_t group /* IN */ ) { 122670: 55 push %ebp <== NOT EXECUTED 122671: 89 e5 mov %esp,%ebp <== NOT EXECUTED 122673: 57 push %edi <== NOT EXECUTED 122674: 56 push %esi <== NOT EXECUTED 122675: 53 push %ebx <== NOT EXECUTED 122676: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 122679: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 12267c: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED IMFS_jnode_t *jnode; #if defined(RTEMS_POSIX_API) uid_t st_uid; #endif jnode = (IMFS_jnode_t *) pathloc->node_access; 12267f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 122682: 8b 18 mov (%eax),%ebx <== NOT EXECUTED /* * Verify I am the owner of the node or the super user. */ #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 122684: e8 c7 18 00 00 call 123f50 <== NOT EXECUTED if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) 122689: 66 3b 43 3c cmp 0x3c(%ebx),%ax <== NOT EXECUTED 12268d: 74 05 je 122694 <== NOT EXECUTED 12268f: 66 85 c0 test %ax,%ax <== NOT EXECUTED 122692: 75 2c jne 1226c0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EPERM ); #endif jnode->st_uid = owner; 122694: 66 89 73 3c mov %si,0x3c(%ebx) <== NOT EXECUTED jnode->st_gid = group; 122698: 66 89 7b 3e mov %di,0x3e(%ebx) <== NOT EXECUTED IMFS_update_ctime( jnode ); 12269c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12269f: 6a 00 push $0x0 <== NOT EXECUTED 1226a1: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 1226a4: 50 push %eax <== NOT EXECUTED 1226a5: e8 42 8d fe ff call 10b3ec <== NOT EXECUTED 1226aa: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1226ad: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 1226b0: 31 c0 xor %eax,%eax <== NOT EXECUTED 1226b2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 1226b5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1226b8: 5b pop %ebx <== NOT EXECUTED 1226b9: 5e pop %esi <== NOT EXECUTED 1226ba: 5f pop %edi <== NOT EXECUTED 1226bb: c9 leave <== NOT EXECUTED 1226bc: c3 ret <== NOT EXECUTED 1226bd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED #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 ); 1226c0: e8 8f f1 00 00 call 131854 <__errno> <== NOT EXECUTED 1226c5: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 1226cb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1226d0: eb e3 jmp 1226b5 <== NOT EXECUTED 0011019c : IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) { 11019c: 55 push %ebp <== NOT EXECUTED 11019d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11019f: 57 push %edi <== NOT EXECUTED 1101a0: 56 push %esi <== NOT EXECUTED 1101a1: 53 push %ebx <== NOT EXECUTED 1101a2: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1101a5: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *node; struct timeval tv; IMFS_jnode_t *parent = NULL; IMFS_fs_info_t *fs_info; if ( parent_loc != NULL ) 1101a8: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1101ab: 85 db test %ebx,%ebx <== NOT EXECUTED 1101ad: 0f 84 31 01 00 00 je 1102e4 <== NOT EXECUTED parent = parent_loc->node_access; 1101b3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1101b6: 8b 38 mov (%eax),%edi <== NOT EXECUTED /* * Allocate an IMFS jnode */ node = calloc( 1, sizeof( IMFS_jnode_t ) ); 1101b8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1101bb: 6a 60 push $0x60 <== NOT EXECUTED 1101bd: 6a 01 push $0x1 <== NOT EXECUTED 1101bf: e8 30 e3 ff ff call 10e4f4 <== NOT EXECUTED 1101c4: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !node ) 1101c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1101c9: 85 c0 test %eax,%eax <== NOT EXECUTED 1101cb: 0f 84 a7 00 00 00 je 110278 <== NOT EXECUTED /* * Fill in the basic information */ node->st_nlink = 1; 1101d1: 66 c7 40 34 01 00 movw $0x1,0x34(%eax) <== NOT EXECUTED node->type = type; 1101d7: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 1101da: 89 50 4c mov %edx,0x4c(%eax) <== NOT EXECUTED strncpy( node->name, name, IMFS_NAME_MAX ); 1101dd: 51 push %ecx <== NOT EXECUTED 1101de: 6a 20 push $0x20 <== NOT EXECUTED 1101e0: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1101e3: 8d 40 0c lea 0xc(%eax),%eax <== NOT EXECUTED 1101e6: 50 push %eax <== NOT EXECUTED 1101e7: e8 1c 1c 00 00 call 111e08 <== NOT EXECUTED /* * Fill in the mode and permission information for the jnode structure. */ node->st_mode = mode & ~rtems_filesystem_umask; 1101ec: a1 74 d5 11 00 mov 0x11d574,%eax <== NOT EXECUTED 1101f1: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED 1101f4: f7 d0 not %eax <== NOT EXECUTED 1101f6: 21 c6 and %eax,%esi <== NOT EXECUTED 1101f8: 89 73 30 mov %esi,0x30(%ebx) <== NOT EXECUTED #if defined(RTEMS_POSIX_API) node->st_uid = geteuid(); 1101fb: e8 9c e4 ff ff call 10e69c <== NOT EXECUTED 110200: 66 89 43 3c mov %ax,0x3c(%ebx) <== NOT EXECUTED node->st_gid = getegid(); 110204: e8 83 e4 ff ff call 10e68c <== NOT EXECUTED 110209: 66 89 43 3e mov %ax,0x3e(%ebx) <== NOT EXECUTED /* * Now set all the times. */ gettimeofday( &tv, 0 ); 11020d: 58 pop %eax <== NOT EXECUTED 11020e: 5a pop %edx <== NOT EXECUTED 11020f: 6a 00 push $0x0 <== NOT EXECUTED 110211: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 110214: 50 push %eax <== NOT EXECUTED 110215: e8 92 e4 ff ff call 10e6ac <== NOT EXECUTED node->stat_atime = (time_t) tv.tv_sec; 11021a: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11021d: 89 43 40 mov %eax,0x40(%ebx) <== NOT EXECUTED node->stat_mtime = (time_t) tv.tv_sec; 110220: 89 43 44 mov %eax,0x44(%ebx) <== NOT EXECUTED node->stat_ctime = (time_t) tv.tv_sec; 110223: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED /* * Set the type specific information */ switch (type) { 110226: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110229: 83 7d 0c 06 cmpl $0x6,0xc(%ebp) <== NOT EXECUTED 11022d: 76 55 jbe 110284 <== NOT EXECUTED node->info.file.doubly_indirect = 0; node->info.file.triply_indirect = 0; break; default: assert(0); 11022f: 68 e8 8c 11 00 push $0x118ce8 <== NOT EXECUTED 110234: 68 18 99 11 00 push $0x119918 <== NOT EXECUTED 110239: 6a 74 push $0x74 <== NOT EXECUTED 11023b: 68 b0 98 11 00 push $0x1198b0 <== NOT EXECUTED 110240: e8 23 6c ff ff call 106e68 <__assert_func> <== NOT EXECUTED 110245: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED case IMFS_HARD_LINK: node->info.hard_link.link_node = info->hard_link.link_node; break; case IMFS_SYM_LINK: node->info.sym_link.name = info->sym_link.name; 110248: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 11024b: 8b 02 mov (%edx),%eax <== NOT EXECUTED 11024d: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED /* * If this node has a parent, then put it in that directory list. */ if ( parent ) { 110250: 85 ff test %edi,%edi <== NOT EXECUTED 110252: 74 24 je 110278 <== NOT EXECUTED 110254: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 110257: 53 push %ebx <== NOT EXECUTED 110258: 8d 47 50 lea 0x50(%edi),%eax <== NOT EXECUTED 11025b: 50 push %eax <== NOT EXECUTED 11025c: e8 7b ab ff ff call 10addc <_Chain_Append> <== NOT EXECUTED rtems_chain_append( &parent->info.directory.Entries, &node->Node ); node->Parent = parent; 110261: 89 7b 08 mov %edi,0x8(%ebx) <== NOT EXECUTED fs_info = parent_loc->mt_entry->fs_info; 110264: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 110267: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 11026a: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED node->st_ino = ++fs_info->ino_count; 11026d: 8b 02 mov (%edx),%eax <== NOT EXECUTED 11026f: 40 inc %eax <== NOT EXECUTED 110270: 89 02 mov %eax,(%edx) <== NOT EXECUTED 110272: 89 43 38 mov %eax,0x38(%ebx) <== NOT EXECUTED 110275: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return node; } 110278: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11027a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11027d: 5b pop %ebx <== NOT EXECUTED 11027e: 5e pop %esi <== NOT EXECUTED 11027f: 5f pop %edi <== NOT EXECUTED 110280: c9 leave <== NOT EXECUTED 110281: c3 ret <== NOT EXECUTED 110282: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Set the type specific information */ switch (type) { 110284: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 110287: ff 24 85 fc 98 11 00 jmp *0x1198fc(,%eax,4) <== NOT EXECUTED 11028e: 66 90 xchg %ax,%ax <== NOT EXECUTED node->info.device.major = info->device.major; node->info.device.minor = info->device.minor; break; case IMFS_LINEAR_FILE: node->info.linearfile.size = 0; 110290: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED node->info.linearfile.direct = 0; 110297: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED case IMFS_MEMORY_FILE: node->info.file.size = 0; 11029e: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED node->info.file.indirect = 0; 1102a5: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED node->info.file.doubly_indirect = 0; 1102ac: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED node->info.file.triply_indirect = 0; 1102b3: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED 1102ba: eb 94 jmp 110250 <== NOT EXECUTED case IMFS_SYM_LINK: node->info.sym_link.name = info->sym_link.name; break; case IMFS_DEVICE: node->info.device.major = info->device.major; 1102bc: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 1102bf: 8b 02 mov (%edx),%eax <== NOT EXECUTED 1102c1: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED node->info.device.minor = info->device.minor; 1102c4: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 1102c7: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED 1102ca: eb 84 jmp 110250 <== NOT EXECUTED 1102cc: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 1102cf: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED 1102d2: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED 1102d9: 8d 43 50 lea 0x50(%ebx),%eax <== NOT EXECUTED 1102dc: 89 43 58 mov %eax,0x58(%ebx) <== NOT EXECUTED 1102df: e9 6c ff ff ff jmp 110250 <== NOT EXECUTED IMFS_jnode_t *node; struct timeval tv; IMFS_jnode_t *parent = NULL; IMFS_fs_info_t *fs_info; if ( parent_loc != NULL ) 1102e4: 31 ff xor %edi,%edi <== NOT EXECUTED 1102e6: e9 cd fe ff ff jmp 1101b8 <== NOT EXECUTED 00108908 : * NOTE: Assuming the "/" directory is bad. * Not checking that the starting directory is in an IMFS is bad. */ void IMFS_dump( void ) { 108908: 55 push %ebp <== NOT EXECUTED 108909: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10890b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED fprintf(stdout, "*************** Dump of Entire IMFS ***************\n" ); 10890e: a1 40 47 12 00 mov 0x124740,%eax <== NOT EXECUTED 108913: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 108916: 6a 34 push $0x34 <== NOT EXECUTED 108918: 6a 01 push $0x1 <== NOT EXECUTED 10891a: 68 d8 f0 11 00 push $0x11f0d8 <== NOT EXECUTED 10891f: e8 70 d0 00 00 call 115994 <== NOT EXECUTED fprintf(stdout, "/\n" ); 108924: a1 40 47 12 00 mov 0x124740,%eax <== NOT EXECUTED 108929: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10892c: 6a 02 push $0x2 <== NOT EXECUTED 10892e: 6a 01 push $0x1 <== NOT EXECUTED 108930: 68 47 f0 11 00 push $0x11f047 <== NOT EXECUTED 108935: e8 5a d0 00 00 call 115994 <== NOT EXECUTED IMFS_dump_directory( rtems_filesystem_root.node_access, 0 ); 10893a: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10893d: 6a 00 push $0x0 <== NOT EXECUTED 10893f: a1 20 42 12 00 mov 0x124220,%eax <== NOT EXECUTED 108944: ff 70 14 pushl 0x14(%eax) <== NOT EXECUTED 108947: e8 e8 fe ff ff call 108834 <== NOT EXECUTED fprintf(stdout, "*************** End of Dump ***************\n" ); 10894c: a1 40 47 12 00 mov 0x124740,%eax <== NOT EXECUTED 108951: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 108954: 6a 39 push $0x39 <== NOT EXECUTED 108956: 6a 01 push $0x1 <== NOT EXECUTED 108958: 68 10 f1 11 00 push $0x11f110 <== NOT EXECUTED 10895d: e8 32 d0 00 00 call 115994 <== NOT EXECUTED 108962: 83 c4 20 add $0x20,%esp <== NOT EXECUTED } 108965: c9 leave <== NOT EXECUTED 108966: c3 ret <== NOT EXECUTED 00108834 : void IMFS_dump_directory( IMFS_jnode_t *the_directory, int level ) { 108834: 55 push %ebp <== NOT EXECUTED 108835: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108837: 57 push %edi <== NOT EXECUTED 108838: 56 push %esi <== NOT EXECUTED 108839: 53 push %ebx <== NOT EXECUTED 10883a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10883d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108840: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED rtems_chain_node *the_node; rtems_chain_control *the_chain; IMFS_jnode_t *the_jnode; int i; assert( the_directory ); 108843: 85 c0 test %eax,%eax <== NOT EXECUTED 108845: 74 76 je 1088bd <== NOT EXECUTED assert( level >= 0 ); 108847: 85 ff test %edi,%edi <== NOT EXECUTED 108849: 0f 88 9d 00 00 00 js 1088ec <== NOT EXECUTED assert( the_directory->type == IMFS_DIRECTORY ); 10884f: 83 78 4c 01 cmpl $0x1,0x4c(%eax) <== NOT EXECUTED 108853: 75 7e jne 1088d3 <== NOT EXECUTED the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; 108855: 8b 70 50 mov 0x50(%eax),%esi <== NOT EXECUTED 108858: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 10885b: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED !rtems_chain_is_tail( the_chain, the_node ); 10885e: 39 c6 cmp %eax,%esi <== NOT EXECUTED 108860: 74 41 je 1088a3 <== NOT EXECUTED 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 ); 108862: 8d 47 01 lea 0x1(%edi),%eax <== NOT EXECUTED 108865: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED for ( the_node = the_chain->first; !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; 108868: 31 db xor %ebx,%ebx <== NOT EXECUTED 10886a: 66 90 xchg %ax,%ax <== NOT EXECUTED for ( i=0 ; i<=level ; i++ ) fprintf(stdout, "...." ); 10886c: a1 40 47 12 00 mov 0x124740,%eax <== NOT EXECUTED 108871: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 108874: 6a 04 push $0x4 <== NOT EXECUTED 108876: 6a 01 push $0x1 <== NOT EXECUTED 108878: 68 42 f0 11 00 push $0x11f042 <== NOT EXECUTED 10887d: e8 12 d1 00 00 call 115994 <== NOT EXECUTED !rtems_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++ ) 108882: 43 inc %ebx <== NOT EXECUTED 108883: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108886: 39 df cmp %ebx,%edi <== NOT EXECUTED 108888: 7d e2 jge 10886c <== NOT EXECUTED fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); 10888a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10888d: 56 push %esi <== NOT EXECUTED 10888e: e8 25 fe ff ff call 1086b8 <== NOT EXECUTED if ( the_jnode->type == IMFS_DIRECTORY ) 108893: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108896: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) <== NOT EXECUTED 10889a: 74 10 je 1088ac <== NOT EXECUTED the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; !rtems_chain_is_tail( the_chain, the_node ); the_node = the_node->next ) { 10889c: 8b 36 mov (%esi),%esi <== NOT EXECUTED assert( the_directory->type == IMFS_DIRECTORY ); the_chain = &the_directory->info.directory.Entries; for ( the_node = the_chain->first; !rtems_chain_is_tail( the_chain, the_node ); 10889e: 3b 75 f0 cmp -0x10(%ebp),%esi <== NOT EXECUTED 1088a1: 75 c5 jne 108868 <== NOT EXECUTED fprintf(stdout, "...." ); IMFS_print_jnode( the_jnode ); if ( the_jnode->type == IMFS_DIRECTORY ) IMFS_dump_directory( the_jnode, level + 1 ); } } 1088a3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1088a6: 5b pop %ebx <== NOT EXECUTED 1088a7: 5e pop %esi <== NOT EXECUTED 1088a8: 5f pop %edi <== NOT EXECUTED 1088a9: c9 leave <== NOT EXECUTED 1088aa: c3 ret <== NOT EXECUTED 1088ab: 90 nop <== NOT EXECUTED 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 ); 1088ac: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1088af: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 1088b2: 56 push %esi <== NOT EXECUTED 1088b3: e8 7c ff ff ff call 108834 <== NOT EXECUTED 1088b8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1088bb: eb df jmp 10889c <== NOT EXECUTED rtems_chain_node *the_node; rtems_chain_control *the_chain; IMFS_jnode_t *the_jnode; int i; assert( the_directory ); 1088bd: 68 29 f0 11 00 push $0x11f029 <== NOT EXECUTED 1088c2: 68 68 f1 11 00 push $0x11f168 <== NOT EXECUTED 1088c7: 6a 7f push $0x7f <== NOT EXECUTED 1088c9: 68 64 f0 11 00 push $0x11f064 <== NOT EXECUTED 1088ce: e8 09 06 00 00 call 108edc <__assert_func> <== NOT EXECUTED assert( level >= 0 ); assert( the_directory->type == IMFS_DIRECTORY ); 1088d3: 68 b0 f0 11 00 push $0x11f0b0 <== NOT EXECUTED 1088d8: 68 68 f1 11 00 push $0x11f168 <== NOT EXECUTED 1088dd: 68 83 00 00 00 push $0x83 <== NOT EXECUTED 1088e2: 68 64 f0 11 00 push $0x11f064 <== NOT EXECUTED 1088e7: e8 f0 05 00 00 call 108edc <__assert_func> <== NOT EXECUTED IMFS_jnode_t *the_jnode; int i; assert( the_directory ); assert( level >= 0 ); 1088ec: 68 37 f0 11 00 push $0x11f037 <== NOT EXECUTED 1088f1: 68 68 f1 11 00 push $0x11f168 <== NOT EXECUTED 1088f6: 68 81 00 00 00 push $0x81 <== NOT EXECUTED 1088fb: 68 64 f0 11 00 push $0x11f064 <== NOT EXECUTED 108900: e8 d7 05 00 00 call 108edc <__assert_func> <== NOT EXECUTED 0010da48 : int IMFS_eval_path( const char *pathname, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10da48: 55 push %ebp <== NOT EXECUTED 10da49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10da4b: 57 push %edi <== NOT EXECUTED 10da4c: 56 push %esi <== NOT EXECUTED 10da4d: 53 push %ebx <== NOT EXECUTED 10da4e: 83 ec 5c sub $0x5c,%esp <== NOT EXECUTED /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10da51: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10da54: 8b 30 mov (%eax),%esi <== NOT EXECUTED 10da56: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp) <== NOT EXECUTED * 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 ); 10da5d: 50 push %eax <== NOT EXECUTED 10da5e: 8d 55 f0 lea -0x10(%ebp),%edx <== NOT EXECUTED 10da61: 52 push %edx <== NOT EXECUTED 10da62: 8d 4d bf lea -0x41(%ebp),%ecx <== NOT EXECUTED 10da65: 51 push %ecx <== NOT EXECUTED 10da66: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10da69: 03 45 a4 add -0x5c(%ebp),%eax <== NOT EXECUTED 10da6c: 50 push %eax <== NOT EXECUTED 10da6d: e8 fa 05 00 00 call 10e06c <== NOT EXECUTED 10da72: 89 c3 mov %eax,%ebx <== NOT EXECUTED i += len; 10da74: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED if ( !pathloc->node_access ) 10da77: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10da7a: 8b 17 mov (%edi),%edx <== NOT EXECUTED 10da7c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10da7f: 85 d2 test %edx,%edx <== NOT EXECUTED 10da81: 0f 84 95 01 00 00 je 10dc1c <== NOT EXECUTED */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], token, &len ); i += len; 10da87: 01 45 a4 add %eax,-0x5c(%ebp) <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOENT ); /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10da8a: 85 db test %ebx,%ebx <== NOT EXECUTED 10da8c: 75 52 jne 10dae0 <== NOT EXECUTED * 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 ) { 10da8e: 83 7a 4c 01 cmpl $0x1,0x4c(%edx) <== NOT EXECUTED 10da92: 0f 85 30 01 00 00 jne 10dbc8 <== NOT EXECUTED if ( node->info.directory.mt_fs != NULL ) { 10da98: 8b 52 5c mov 0x5c(%edx),%edx <== NOT EXECUTED 10da9b: 85 d2 test %edx,%edx <== NOT EXECUTED 10da9d: 0f 84 25 01 00 00 je 10dbc8 <== NOT EXECUTED newloc = node->info.directory.mt_fs->mt_fs_root; 10daa3: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 10daa6: 8d 72 18 lea 0x18(%edx),%esi <== NOT EXECUTED 10daa9: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10daae: 89 c7 mov %eax,%edi <== NOT EXECUTED 10dab0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10dab2: 89 c6 mov %eax,%esi <== NOT EXECUTED 10dab4: b1 04 mov $0x4,%cl <== NOT EXECUTED 10dab6: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10dab9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc ); 10dabb: 57 push %edi <== NOT EXECUTED 10dabc: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10dabf: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10dac2: 50 push %eax <== NOT EXECUTED 10dac3: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dac6: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10dac9: 29 4d a4 sub %ecx,-0x5c(%ebp) <== NOT EXECUTED 10dacc: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10dacf: 03 45 a4 add -0x5c(%ebp),%eax <== NOT EXECUTED 10dad2: 50 push %eax <== NOT EXECUTED 10dad3: ff 12 call *(%edx) <== NOT EXECUTED 10dad5: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10dad7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dada: e9 bd 00 00 00 jmp 10db9c <== NOT EXECUTED 10dadf: 90 nop <== NOT EXECUTED /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) 10dae0: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) <== NOT EXECUTED 10dae4: 0f 84 be 00 00 00 je 10dba8 <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; 10daea: 89 d6 mov %edx,%esi <== NOT EXECUTED switch( type ) { 10daec: 83 fb 03 cmp $0x3,%ebx <== NOT EXECUTED 10daef: 74 1b je 10db0c <== NOT EXECUTED 10daf1: 83 fb 04 cmp $0x4,%ebx <== NOT EXECUTED 10daf4: 0f 84 92 00 00 00 je 10db8c <== NOT EXECUTED 10dafa: 83 fb 02 cmp $0x2,%ebx <== NOT EXECUTED 10dafd: 74 59 je 10db58 <== NOT EXECUTED /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10daff: 83 fb 04 cmp $0x4,%ebx <== NOT EXECUTED 10db02: 0f 85 55 ff ff ff jne 10da5d <== NOT EXECUTED 10db08: eb 84 jmp 10da8e <== NOT EXECUTED 10db0a: 66 90 xchg %ax,%ax <== NOT EXECUTED case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 10db0c: 8b 42 4c mov 0x4c(%edx),%eax <== NOT EXECUTED 10db0f: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10db12: 0f 84 e0 00 00 00 je 10dbf8 <== NOT EXECUTED node = pathloc->node_access; if ( !node ) rtems_set_errno_and_return_minus_one( ENOTDIR ); } else if ( node->type == IMFS_SYM_LINK ) { 10db18: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10db1b: 0f 84 3b 01 00 00 je 10dc5c <== NOT EXECUTED /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10db21: 48 dec %eax <== NOT EXECUTED 10db22: 0f 85 09 01 00 00 jne 10dc31 <== NOT EXECUTED /* * If we are at a node that is a mount point. Set loc to the * new fs root node and let them finish evaluating the path. */ if ( node->info.directory.mt_fs != NULL ) { 10db28: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED 10db2b: 85 c0 test %eax,%eax <== NOT EXECUTED 10db2d: 0f 85 13 01 00 00 jne 10dc46 <== NOT EXECUTED /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10db33: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10db36: 8d 7d bf lea -0x41(%ebp),%edi <== NOT EXECUTED 10db39: 57 push %edi <== NOT EXECUTED 10db3a: 56 push %esi <== NOT EXECUTED 10db3b: e8 88 04 00 00 call 10dfc8 <== NOT EXECUTED 10db40: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !node ) 10db42: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10db45: 85 c0 test %eax,%eax <== NOT EXECUTED 10db47: 0f 84 cf 00 00 00 je 10dc1c <== NOT EXECUTED /* * Set the node access to the point we have found. */ pathloc->node_access = node; 10db4d: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10db50: 89 30 mov %esi,(%eax) <== NOT EXECUTED 10db52: e9 06 ff ff ff jmp 10da5d <== NOT EXECUTED 10db57: 90 nop <== 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 ) 10db58: a1 74 d5 11 00 mov 0x11d574,%eax <== NOT EXECUTED 10db5d: 39 50 14 cmp %edx,0x14(%eax) <== NOT EXECUTED 10db60: 0f 84 f7 fe ff ff je 10da5d <== NOT EXECUTED /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 10db66: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10db69: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED 10db6c: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED 10db6f: 0f 84 0b 01 00 00 je 10dc80 <== NOT EXECUTED *pathloc = newloc; return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc); } } else { if ( !node->Parent ) 10db75: 8b 72 08 mov 0x8(%edx),%esi <== NOT EXECUTED 10db78: 85 f6 test %esi,%esi <== NOT EXECUTED 10db7a: 0f 84 9c 00 00 00 je 10dc1c <== NOT EXECUTED node = node->Parent; pathloc->node_access = node; } pathloc->node_access = node; 10db80: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10db83: 89 37 mov %esi,(%edi) <== NOT EXECUTED 10db85: e9 d3 fe ff ff jmp 10da5d <== NOT EXECUTED 10db8a: 66 90 xchg %ax,%ax <== NOT EXECUTED case IMFS_NO_MORE_PATH: case IMFS_CURRENT_DIR: break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10db8c: e8 ef 30 00 00 call 110c80 <__errno> <== NOT EXECUTED 10db91: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED 10db97: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10db9c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10db9e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dba1: 5b pop %ebx <== NOT EXECUTED 10dba2: 5e pop %esi <== NOT EXECUTED 10dba3: 5f pop %edi <== NOT EXECUTED 10dba4: c9 leave <== NOT EXECUTED 10dba5: c3 ret <== NOT EXECUTED 10dba6: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10dba8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dbab: 6a 01 push $0x1 <== NOT EXECUTED 10dbad: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dbb0: e8 3b fd ff ff call 10d8f0 <== NOT EXECUTED 10dbb5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dbb8: 85 c0 test %eax,%eax <== NOT EXECUTED 10dbba: 74 29 je 10dbe5 <== NOT EXECUTED 10dbbc: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10dbbf: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10dbc1: e9 24 ff ff ff jmp 10daea <== NOT EXECUTED 10dbc6: 66 90 xchg %ax,%ax <== NOT EXECUTED return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc ); } else { result = IMFS_Set_handlers( pathloc ); } } else { result = IMFS_Set_handlers( pathloc ); 10dbc8: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dbcb: e8 d0 fc ff ff call 10d8a0 <== NOT EXECUTED 10dbd0: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10dbd2: 56 push %esi <== NOT EXECUTED /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) 10dbd3: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dbd6: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dbd9: e8 12 fd ff ff call 10d8f0 <== NOT EXECUTED 10dbde: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dbe1: 85 c0 test %eax,%eax <== NOT EXECUTED 10dbe3: 75 b7 jne 10db9c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); 10dbe5: e8 96 30 00 00 call 110c80 <__errno> <== NOT EXECUTED 10dbea: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10dbf0: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10dbf5: eb a5 jmp 10db9c <== NOT EXECUTED 10dbf7: 90 nop <== NOT EXECUTED * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { IMFS_evaluate_hard_link( pathloc, 0 ); 10dbf8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dbfb: 6a 00 push $0x0 <== NOT EXECUTED 10dbfd: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dc00: e8 33 fd ff ff call 10d938 <== NOT EXECUTED node = pathloc->node_access; 10dc05: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10dc08: 8b 30 mov (%eax),%esi <== NOT EXECUTED if ( !node ) 10dc0a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dc0d: 85 f6 test %esi,%esi <== NOT EXECUTED 10dc0f: 74 20 je 10dc31 <== NOT EXECUTED } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_sym_link( pathloc, 0 ); node = pathloc->node_access; 10dc11: 8b 46 4c mov 0x4c(%esi),%eax <== NOT EXECUTED 10dc14: e9 08 ff ff ff jmp 10db21 <== NOT EXECUTED 10dc19: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); if ( !node ) rtems_set_errno_and_return_minus_one( ENOENT ); 10dc1c: e8 5f 30 00 00 call 110c80 <__errno> <== NOT EXECUTED 10dc21: c7 00 02 00 00 00 movl $0x2,(%eax) <== NOT EXECUTED 10dc27: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10dc2c: e9 6b ff ff ff jmp 10db9c <== NOT EXECUTED /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 10dc31: e8 4a 30 00 00 call 110c80 <__errno> <== NOT EXECUTED 10dc36: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 10dc3c: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10dc41: e9 56 ff ff ff jmp 10db9c <== NOT EXECUTED * If we are at a node that is a mount point. Set loc to the * new fs root node and let them finish evaluating the path. */ if ( node->info.directory.mt_fs != NULL ) { newloc = node->info.directory.mt_fs->mt_fs_root; 10dc46: 8d 55 e0 lea -0x20(%ebp),%edx <== NOT EXECUTED 10dc49: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 10dc4c: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10dc51: 89 d7 mov %edx,%edi <== NOT EXECUTED 10dc53: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10dc55: 89 d6 mov %edx,%esi <== NOT EXECUTED 10dc57: e9 58 fe ff ff jmp 10dab4 <== NOT EXECUTED if ( !node ) rtems_set_errno_and_return_minus_one( ENOTDIR ); } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_sym_link( pathloc, 0 ); 10dc5c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dc5f: 6a 00 push $0x0 <== NOT EXECUTED 10dc61: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dc64: e8 27 fd ff ff call 10d990 <== NOT EXECUTED 10dc69: 89 c3 mov %eax,%ebx <== NOT EXECUTED node = pathloc->node_access; 10dc6b: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10dc6e: 8b 02 mov (%edx),%eax <== NOT EXECUTED if ( result == -1 ) 10dc70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dc73: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED 10dc76: 0f 84 20 ff ff ff je 10db9c <== NOT EXECUTED } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_sym_link( pathloc, 0 ); node = pathloc->node_access; 10dc7c: 89 c6 mov %eax,%esi <== NOT EXECUTED 10dc7e: eb 91 jmp 10dc11 <== NOT EXECUTED */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; /* Throw out the .. in this case */ } else { newloc = pathloc->mt_entry->mt_point_node; 10dc80: 8d 55 e0 lea -0x20(%ebp),%edx <== NOT EXECUTED 10dc83: 8d 70 08 lea 0x8(%eax),%esi <== NOT EXECUTED 10dc86: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10dc8b: 89 d7 mov %edx,%edi <== NOT EXECUTED 10dc8d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10dc8f: 89 d6 mov %edx,%esi <== NOT EXECUTED 10dc91: e9 1e fe ff ff jmp 10dab4 <== NOT EXECUTED 0010dd44 : int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { 10dd44: 55 push %ebp <== NOT EXECUTED 10dd45: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dd47: 57 push %edi <== NOT EXECUTED 10dd48: 56 push %esi <== NOT EXECUTED 10dd49: 53 push %ebx <== NOT EXECUTED 10dd4a: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10dd4d: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10dd50: 8b 18 mov (%eax),%ebx <== NOT EXECUTED 10dd52: c7 45 b0 00 00 00 00 movl $0x0,-0x50(%ebp) <== NOT EXECUTED * Evaluate all tokens until we are done or an error occurs. */ while( !done ) { type = IMFS_get_token( &path[i], token, &len ); 10dd59: 56 push %esi <== NOT EXECUTED 10dd5a: 8d 55 f0 lea -0x10(%ebp),%edx <== NOT EXECUTED 10dd5d: 52 push %edx <== NOT EXECUTED 10dd5e: 8d 4d bf lea -0x41(%ebp),%ecx <== NOT EXECUTED 10dd61: 51 push %ecx <== NOT EXECUTED 10dd62: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10dd65: 03 45 b0 add -0x50(%ebp),%eax <== NOT EXECUTED 10dd68: 50 push %eax <== NOT EXECUTED 10dd69: e8 fe 02 00 00 call 10e06c <== NOT EXECUTED 10dd6e: 89 c6 mov %eax,%esi <== NOT EXECUTED i += len; 10dd70: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED if ( !pathloc->node_access ) 10dd73: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10dd76: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10dd78: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dd7b: 85 d2 test %edx,%edx <== NOT EXECUTED 10dd7d: 0f 84 1f 01 00 00 je 10dea2 <== NOT EXECUTED /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10dd83: 85 f6 test %esi,%esi <== NOT EXECUTED 10dd85: 75 1d jne 10dda4 <== NOT EXECUTED pathloc->node_access = node; break; case IMFS_NO_MORE_PATH: rtems_set_errno_and_return_minus_one( EEXIST ); 10dd87: e8 f4 2e 00 00 call 110c80 <__errno> <== NOT EXECUTED 10dd8c: c7 00 11 00 00 00 movl $0x11,(%eax) <== NOT EXECUTED 10dd92: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10dd97: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10dd99: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dd9c: 5b pop %ebx <== NOT EXECUTED 10dd9d: 5e pop %esi <== NOT EXECUTED 10dd9e: 5f pop %edi <== NOT EXECUTED 10dd9f: c9 leave <== NOT EXECUTED 10dda0: c3 ret <== NOT EXECUTED 10dda1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) 10dda4: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) <== NOT EXECUTED 10dda8: 0f 84 0e 01 00 00 je 10debc <== NOT EXECUTED */ while( !done ) { type = IMFS_get_token( &path[i], token, &len ); i += len; 10ddae: 01 7d b0 add %edi,-0x50(%ebp) <== NOT EXECUTED if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; 10ddb1: 89 d3 mov %edx,%ebx <== NOT EXECUTED switch( type ) { 10ddb3: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED 10ddb6: 0f 84 88 00 00 00 je 10de44 <== NOT EXECUTED 10ddbc: 76 26 jbe 10dde4 <== NOT EXECUTED 10ddbe: 83 fe 03 cmp $0x3,%esi <== NOT EXECUTED 10ddc1: 74 2d je 10ddf0 <== NOT EXECUTED 10ddc3: 83 fe 04 cmp $0x4,%esi <== NOT EXECUTED 10ddc6: 75 91 jne 10dd59 <== NOT EXECUTED case IMFS_NO_MORE_PATH: rtems_set_errno_and_return_minus_one( EEXIST ); break; case IMFS_INVALID_TOKEN: rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 10ddc8: e8 b3 2e 00 00 call 110c80 <__errno> <== NOT EXECUTED 10ddcd: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED 10ddd3: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10ddd8: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10ddda: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dddd: 5b pop %ebx <== NOT EXECUTED 10ddde: 5e pop %esi <== NOT EXECUTED 10dddf: 5f pop %edi <== NOT EXECUTED 10dde0: c9 leave <== NOT EXECUTED 10dde1: c3 ret <== NOT EXECUTED 10dde2: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; switch( type ) { 10dde4: 85 f6 test %esi,%esi <== NOT EXECUTED 10dde6: 74 9f je 10dd87 <== NOT EXECUTED 10dde8: e9 6c ff ff ff jmp 10dd59 <== NOT EXECUTED 10dded: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED pathloc->node_access = node; break; case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { 10ddf0: 8b 42 4c mov 0x4c(%edx),%eax <== NOT EXECUTED 10ddf3: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10ddf6: 0f 84 74 01 00 00 je 10df70 <== NOT EXECUTED result = IMFS_evaluate_link( pathloc, 0 ); if ( result == -1 ) return -1; } else if ( node->type == IMFS_SYM_LINK ) { 10ddfc: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10ddff: 0f 84 90 01 00 00 je 10df95 <== NOT EXECUTED if ( result == -1 ) return -1; } node = pathloc->node_access; if ( !node ) 10de05: 85 db test %ebx,%ebx <== NOT EXECUTED 10de07: 0f 84 12 01 00 00 je 10df1f <== NOT EXECUTED /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10de0d: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) <== NOT EXECUTED 10de11: 0f 85 08 01 00 00 jne 10df1f <== NOT EXECUTED /* * If we are at a node that is a mount point. Set loc to the * new fs root node and let them finish evaluating the path. */ if ( node->info.directory.mt_fs != NULL ) { 10de17: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED 10de1a: 85 c0 test %eax,%eax <== NOT EXECUTED 10de1c: 0f 85 12 01 00 00 jne 10df34 <== NOT EXECUTED /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10de22: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10de25: 8d 45 bf lea -0x41(%ebp),%eax <== NOT EXECUTED 10de28: 50 push %eax <== NOT EXECUTED 10de29: 53 push %ebx <== NOT EXECUTED 10de2a: e8 99 01 00 00 call 10dfc8 <== NOT EXECUTED 10de2f: 89 c3 mov %eax,%ebx <== NOT EXECUTED /* * If there is no node we have found the name of the node we * wish to create. */ if ( ! node ) 10de31: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10de34: 85 c0 test %eax,%eax <== NOT EXECUTED 10de36: 74 3c je 10de74 <== NOT EXECUTED done = true; else pathloc->node_access = node; 10de38: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10de3b: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10de3d: e9 17 ff ff ff jmp 10dd59 <== NOT EXECUTED 10de42: 66 90 xchg %ax,%ax <== 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 ) 10de44: a1 74 d5 11 00 mov 0x11d574,%eax <== NOT EXECUTED 10de49: 39 50 14 cmp %edx,0x14(%eax) <== NOT EXECUTED 10de4c: 0f 84 07 ff ff ff je 10dd59 <== NOT EXECUTED /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){ 10de52: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10de55: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED 10de58: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED 10de5b: 0f 84 5b 01 00 00 je 10dfbc <== NOT EXECUTED *pathloc = newloc; return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); } } else { if ( !node->Parent ) 10de61: 8b 5a 08 mov 0x8(%edx),%ebx <== NOT EXECUTED 10de64: 85 db test %ebx,%ebx <== NOT EXECUTED 10de66: 74 3a je 10dea2 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOENT ); node = node->Parent; } pathloc->node_access = node; 10de68: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10de6b: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10de6d: e9 e7 fe ff ff jmp 10dd59 <== NOT EXECUTED 10de72: 66 90 xchg %ax,%ax <== NOT EXECUTED case IMFS_CURRENT_DIR: break; } } *name = &path[ i - len ]; 10de74: 8b 45 b0 mov -0x50(%ebp),%eax <== NOT EXECUTED 10de77: 2b 45 f0 sub -0x10(%ebp),%eax <== NOT EXECUTED 10de7a: 03 45 08 add 0x8(%ebp),%eax <== NOT EXECUTED 10de7d: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10de80: 89 01 mov %eax,(%ecx) <== NOT EXECUTED /* * We have evaluated the path as far as we can. * Verify there is not any invalid stuff at the end of the name. */ for( ; path[i] != '\0'; i++) { 10de82: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10de85: 03 45 b0 add -0x50(%ebp),%eax <== NOT EXECUTED 10de88: 8a 10 mov (%eax),%dl <== NOT EXECUTED 10de8a: 84 d2 test %dl,%dl <== NOT EXECUTED 10de8c: 75 0a jne 10de98 <== NOT EXECUTED 10de8e: eb 4c jmp 10dedc <== NOT EXECUTED 10de90: 8a 50 01 mov 0x1(%eax),%dl <== NOT EXECUTED 10de93: 40 inc %eax <== NOT EXECUTED 10de94: 84 d2 test %dl,%dl <== NOT EXECUTED 10de96: 74 44 je 10dedc <== NOT EXECUTED if ( !IMFS_is_separator( path[ i ] ) ) 10de98: 80 fa 2f cmp $0x2f,%dl <== NOT EXECUTED 10de9b: 74 f3 je 10de90 <== NOT EXECUTED 10de9d: 80 fa 5c cmp $0x5c,%dl <== NOT EXECUTED 10dea0: 74 ee je 10de90 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOENT ); 10dea2: e8 d9 2d 00 00 call 110c80 <__errno> <== NOT EXECUTED 10dea7: c7 00 02 00 00 00 movl $0x2,(%eax) <== NOT EXECUTED 10dead: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10deb2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10deb4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10deb7: 5b pop %ebx <== NOT EXECUTED 10deb8: 5e pop %esi <== NOT EXECUTED 10deb9: 5f pop %edi <== NOT EXECUTED 10deba: c9 leave <== NOT EXECUTED 10debb: c3 ret <== NOT EXECUTED * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10debc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10debf: 6a 01 push $0x1 <== NOT EXECUTED 10dec1: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dec4: e8 27 fa ff ff call 10d8f0 <== NOT EXECUTED 10dec9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10decc: 85 c0 test %eax,%eax <== NOT EXECUTED 10dece: 74 3a je 10df0a <== NOT EXECUTED 10ded0: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10ded3: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10ded5: e9 d4 fe ff ff jmp 10ddae <== NOT EXECUTED 10deda: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Verify we can execute and write to this directory. */ result = IMFS_Set_handlers( pathloc ); 10dedc: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dedf: e8 bc f9 ff ff call 10d8a0 <== NOT EXECUTED 10dee4: 89 c3 mov %eax,%ebx <== NOT EXECUTED /* * The returned node must be a directory */ node = pathloc->node_access; if ( node->type != IMFS_DIRECTORY ) 10dee6: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10dee9: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10deeb: 5a pop %edx <== NOT EXECUTED 10deec: 83 78 4c 01 cmpl $0x1,0x4c(%eax) <== NOT EXECUTED 10def0: 75 2d jne 10df1f <== NOT EXECUTED /* * We must have Write and execute permission on the returned node. */ if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) 10def2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10def5: 6a 03 push $0x3 <== NOT EXECUTED 10def7: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10defa: e8 f1 f9 ff ff call 10d8f0 <== NOT EXECUTED 10deff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10df02: 85 c0 test %eax,%eax <== NOT EXECUTED 10df04: 0f 85 8d fe ff ff jne 10dd97 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); 10df0a: e8 71 2d 00 00 call 110c80 <__errno> <== NOT EXECUTED 10df0f: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10df15: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10df1a: e9 78 fe ff ff jmp 10dd97 <== NOT EXECUTED /* * The returned node must be a directory */ node = pathloc->node_access; if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 10df1f: e8 5c 2d 00 00 call 110c80 <__errno> <== NOT EXECUTED 10df24: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 10df2a: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10df2f: e9 63 fe ff ff jmp 10dd97 <== NOT EXECUTED * If we are at a node that is a mount point. Set loc to the * new fs root node and let them finish evaluating the path. */ if ( node->info.directory.mt_fs != NULL ) { newloc = node->info.directory.mt_fs->mt_fs_root; 10df34: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 10df37: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 10df3a: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10df3f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10df41: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED 10df44: b1 04 mov $0x4,%cl <== NOT EXECUTED 10df46: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10df49: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10df4b: 51 push %ecx <== NOT EXECUTED 10df4c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10df4f: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10df52: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10df55: 50 push %eax <== NOT EXECUTED 10df56: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10df59: 29 4d b0 sub %ecx,-0x50(%ebp) <== NOT EXECUTED 10df5c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10df5f: 03 45 b0 add -0x50(%ebp),%eax <== NOT EXECUTED 10df62: 50 push %eax <== NOT EXECUTED 10df63: ff 52 04 call *0x4(%edx) <== NOT EXECUTED 10df66: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10df68: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10df6b: e9 27 fe ff ff jmp 10dd97 <== NOT EXECUTED case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { result = IMFS_evaluate_link( pathloc, 0 ); 10df70: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10df73: 6a 00 push $0x0 <== NOT EXECUTED 10df75: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10df78: e8 1b fd ff ff call 10dc98 <== NOT EXECUTED 10df7d: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( result == -1 ) 10df7f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10df82: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10df85: 0f 84 0c fe ff ff je 10dd97 <== NOT EXECUTED 10df8b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10df8e: 8b 1a mov (%edx),%ebx <== NOT EXECUTED 10df90: e9 70 fe ff ff jmp 10de05 <== NOT EXECUTED return -1; } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_link( pathloc, 0 ); 10df95: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10df98: 6a 00 push $0x0 <== NOT EXECUTED 10df9a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10df9d: e8 f6 fc ff ff call 10dc98 <== NOT EXECUTED 10dfa2: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( result == -1 ) 10dfa4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dfa7: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10dfaa: 0f 84 e7 fd ff ff je 10dd97 <== NOT EXECUTED 10dfb0: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10dfb3: 8b 19 mov (%ecx),%ebx <== NOT EXECUTED 10dfb5: e9 4b fe ff ff jmp 10de05 <== NOT EXECUTED 10dfba: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; } else { newloc = pathloc->mt_entry->mt_point_node; 10dfbc: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 10dfbf: 8d 70 08 lea 0x8(%eax),%esi <== NOT EXECUTED 10dfc2: e9 73 ff ff ff jmp 10df3a <== NOT EXECUTED 0010d938 : int IMFS_evaluate_hard_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10d938: 55 push %ebp <== NOT EXECUTED 10d939: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d93b: 53 push %ebx <== NOT EXECUTED 10d93c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d93f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *jnode = node->node_access; 10d942: 8b 03 mov (%ebx),%eax <== NOT EXECUTED /* * Check for things that should never happen. */ if ( jnode->type != IMFS_HARD_LINK ) 10d944: 83 78 4c 03 cmpl $0x3,0x4c(%eax) <== NOT EXECUTED 10d948: 75 38 jne 10d982 <== NOT EXECUTED /* * Set the hard link value and the handlers. */ node->node_access = jnode->info.hard_link.link_node; 10d94a: 8b 40 50 mov 0x50(%eax),%eax <== NOT EXECUTED 10d94d: 89 03 mov %eax,(%ebx) <== NOT EXECUTED IMFS_Set_handlers( node ); 10d94f: 53 push %ebx <== NOT EXECUTED 10d950: e8 4b ff ff ff call 10d8a0 <== NOT EXECUTED /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 10d955: 50 push %eax <== NOT EXECUTED 10d956: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d959: 53 push %ebx <== NOT EXECUTED 10d95a: e8 91 ff ff ff call 10d8f0 <== NOT EXECUTED 10d95f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d962: 85 c0 test %eax,%eax <== NOT EXECUTED 10d964: 74 0a je 10d970 <== NOT EXECUTED 10d966: 31 c0 xor %eax,%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10d968: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d96b: c9 leave <== NOT EXECUTED 10d96c: c3 ret <== NOT EXECUTED 10d96d: 8d 76 00 lea 0x0(%esi),%esi <== 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 ); 10d970: e8 0b 33 00 00 call 110c80 <__errno> <== NOT EXECUTED 10d975: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10d97b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10d980: eb e6 jmp 10d968 <== NOT EXECUTED /* * Check for things that should never happen. */ if ( jnode->type != IMFS_HARD_LINK ) rtems_fatal_error_occurred (0xABCD0000); 10d982: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d985: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED 10d98a: e8 b9 d0 ff ff call 10aa48 <== NOT EXECUTED 0010dc98 : int IMFS_evaluate_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10dc98: 55 push %ebp <== NOT EXECUTED 10dc99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc9b: 57 push %edi <== NOT EXECUTED 10dc9c: 56 push %esi <== NOT EXECUTED 10dc9d: 53 push %ebx <== NOT EXECUTED 10dc9e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10dca1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10dca4: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10dca7: 8b 15 74 d5 11 00 mov 0x11d574,%edx <== NOT EXECUTED 10dcad: eb 0e jmp 10dcbd <== NOT EXECUTED 10dcaf: 90 nop <== NOT EXECUTED */ if ( jnode->type == IMFS_HARD_LINK ) result = IMFS_evaluate_hard_link( node, flags ); else if (jnode->type == IMFS_SYM_LINK ) 10dcb0: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10dcb3: 74 53 je 10dd08 <== NOT EXECUTED result = IMFS_evaluate_sym_link( node, flags ); } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || ( jnode->type == IMFS_HARD_LINK ) ) ); 10dcb5: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED 10dcb8: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10dcbb: 77 3a ja 10dcf7 <== NOT EXECUTED { IMFS_jnode_t *jnode; int result = 0; do { jnode = node->node_access; 10dcbd: 8b 1e mov (%esi),%ebx <== NOT EXECUTED /* * Increment and check the link counter. */ rtems_filesystem_link_counts ++; 10dcbf: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 10dcc2: 40 inc %eax <== NOT EXECUTED 10dcc3: 66 89 42 28 mov %ax,0x28(%edx) <== NOT EXECUTED if ( rtems_filesystem_link_counts > MAXSYMLINK ) { 10dcc7: 66 83 f8 05 cmp $0x5,%ax <== NOT EXECUTED 10dccb: 77 57 ja 10dd24 <== NOT EXECUTED /* * Follow the Link node. */ if ( jnode->type == IMFS_HARD_LINK ) 10dccd: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10dcd0: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10dcd3: 75 db jne 10dcb0 <== NOT EXECUTED result = IMFS_evaluate_hard_link( node, flags ); 10dcd5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dcd8: 57 push %edi <== NOT EXECUTED 10dcd9: 56 push %esi <== NOT EXECUTED 10dcda: e8 59 fc ff ff call 10d938 <== NOT EXECUTED 10dcdf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else if (jnode->type == IMFS_SYM_LINK ) result = IMFS_evaluate_sym_link( node, flags ); } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || ( jnode->type == IMFS_HARD_LINK ) ) ); 10dce2: 85 c0 test %eax,%eax <== NOT EXECUTED 10dce4: 75 33 jne 10dd19 <== NOT EXECUTED 10dce6: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10dce9: 8b 15 74 d5 11 00 mov 0x11d574,%edx <== NOT EXECUTED 10dcef: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED 10dcf2: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10dcf5: 76 c6 jbe 10dcbd <== NOT EXECUTED 10dcf7: 31 c0 xor %eax,%eax <== NOT EXECUTED /* * Clear link counter. */ rtems_filesystem_link_counts = 0; 10dcf9: 66 c7 42 28 00 00 movw $0x0,0x28(%edx) <== NOT EXECUTED return result; } 10dcff: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dd02: 5b pop %ebx <== NOT EXECUTED 10dd03: 5e pop %esi <== NOT EXECUTED 10dd04: 5f pop %edi <== NOT EXECUTED 10dd05: c9 leave <== NOT EXECUTED 10dd06: c3 ret <== NOT EXECUTED 10dd07: 90 nop <== NOT EXECUTED if ( jnode->type == IMFS_HARD_LINK ) result = IMFS_evaluate_hard_link( node, flags ); else if (jnode->type == IMFS_SYM_LINK ) result = IMFS_evaluate_sym_link( node, flags ); 10dd08: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dd0b: 57 push %edi <== NOT EXECUTED 10dd0c: 56 push %esi <== NOT EXECUTED 10dd0d: e8 7e fc ff ff call 10d990 <== NOT EXECUTED 10dd12: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || ( jnode->type == IMFS_HARD_LINK ) ) ); 10dd15: 85 c0 test %eax,%eax <== NOT EXECUTED 10dd17: 74 cd je 10dce6 <== NOT EXECUTED 10dd19: 8b 15 74 d5 11 00 mov 0x11d574,%edx <== NOT EXECUTED 10dd1f: eb d8 jmp 10dcf9 <== NOT EXECUTED 10dd21: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * Increment and check the link counter. */ rtems_filesystem_link_counts ++; if ( rtems_filesystem_link_counts > MAXSYMLINK ) { rtems_filesystem_link_counts = 0; 10dd24: 66 c7 42 28 00 00 movw $0x0,0x28(%edx) <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ELOOP ); 10dd2a: e8 51 2f 00 00 call 110c80 <__errno> <== NOT EXECUTED 10dd2f: c7 00 5c 00 00 00 movl $0x5c,(%eax) <== NOT EXECUTED 10dd35: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED */ rtems_filesystem_link_counts = 0; return result; } 10dd3a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dd3d: 5b pop %ebx <== NOT EXECUTED 10dd3e: 5e pop %esi <== NOT EXECUTED 10dd3f: 5f pop %edi <== NOT EXECUTED 10dd40: c9 leave <== NOT EXECUTED 10dd41: c3 ret <== NOT EXECUTED 0010d8f0 : int IMFS_evaluate_permission( rtems_filesystem_location_info_t *node, int flags ) { 10d8f0: 55 push %ebp <== NOT EXECUTED 10d8f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d8f3: 56 push %esi <== NOT EXECUTED 10d8f4: 53 push %ebx <== NOT EXECUTED if ( !rtems_libio_is_valid_perms( flags ) ) { assert( 0 ); rtems_set_errno_and_return_minus_one( EIO ); } jnode = node->node_access; 10d8f5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d8f8: 8b 30 mov (%eax),%esi <== NOT EXECUTED #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 10d8fa: e8 9d 0d 00 00 call 10e69c <== NOT EXECUTED 10d8ff: 89 c3 mov %eax,%ebx <== NOT EXECUTED st_gid = getegid(); 10d901: e8 86 0d 00 00 call 10e68c <== NOT EXECUTED * Check if I am owner or a group member or someone else. */ flags_to_test = flags; if ( st_uid == jnode->st_uid ) 10d906: 66 3b 5e 3c cmp 0x3c(%esi),%bx <== NOT EXECUTED 10d90a: 74 24 je 10d930 <== NOT EXECUTED flags_to_test <<= 6; else if ( st_gid == jnode->st_gid ) 10d90c: 66 3b 46 3e cmp 0x3e(%esi),%ax <== NOT EXECUTED 10d910: 74 16 je 10d928 <== NOT EXECUTED 10d912: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10d915: 89 d0 mov %edx,%eax <== NOT EXECUTED 10d917: 23 46 30 and 0x30(%esi),%eax <== NOT EXECUTED 10d91a: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10d91c: 0f 94 c0 sete %al <== NOT EXECUTED 10d91f: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED return 1; return 0; } 10d922: 5b pop %ebx <== NOT EXECUTED 10d923: 5e pop %esi <== NOT EXECUTED 10d924: c9 leave <== NOT EXECUTED 10d925: c3 ret <== NOT EXECUTED 10d926: 66 90 xchg %ax,%ax <== NOT EXECUTED flags_to_test = flags; if ( st_uid == jnode->st_uid ) flags_to_test <<= 6; else if ( st_gid == jnode->st_gid ) flags_to_test <<= 3; 10d928: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10d92b: c1 e2 03 shl $0x3,%edx <== NOT EXECUTED 10d92e: eb e5 jmp 10d915 <== NOT EXECUTED */ flags_to_test = flags; if ( st_uid == jnode->st_uid ) flags_to_test <<= 6; 10d930: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10d933: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 10d936: eb dd jmp 10d915 <== NOT EXECUTED 0010d990 : int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10d990: 55 push %ebp <== NOT EXECUTED 10d991: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d993: 57 push %edi <== NOT EXECUTED 10d994: 56 push %esi <== NOT EXECUTED 10d995: 53 push %ebx <== NOT EXECUTED 10d996: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d999: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *jnode = node->node_access; 10d99c: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10d99f: 8b 02 mov (%edx),%eax <== NOT EXECUTED /* * Check for things that should never happen. */ if ( jnode->type != IMFS_SYM_LINK ) 10d9a1: 83 78 4c 04 cmpl $0x4,0x4c(%eax) <== NOT EXECUTED 10d9a5: 0f 85 83 00 00 00 jne 10da2e <== NOT EXECUTED rtems_fatal_error_occurred (0xABCD0000); if ( !jnode->Parent ) 10d9ab: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10d9ae: 85 d2 test %edx,%edx <== NOT EXECUTED 10d9b0: 0f 84 85 00 00 00 je 10da3b <== NOT EXECUTED /* * Move the node_access to either the symbolic links parent or * root depending on the symbolic links path. */ node->node_access = jnode->Parent; 10d9b6: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10d9b9: 89 11 mov %edx,(%ecx) <== NOT EXECUTED rtems_filesystem_get_sym_start_loc( 10d9bb: 8b 50 50 mov 0x50(%eax),%edx <== NOT EXECUTED 10d9be: 8a 02 mov (%edx),%al <== NOT EXECUTED 10d9c0: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 10d9c2: 74 0c je 10d9d0 <== NOT EXECUTED 10d9c4: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 10d9c6: 74 08 je 10d9d0 <== NOT EXECUTED 10d9c8: 84 c0 test %al,%al <== NOT EXECUTED 10d9ca: 74 04 je 10d9d0 <== NOT EXECUTED 10d9cc: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d9ce: eb 17 jmp 10d9e7 <== NOT EXECUTED 10d9d0: a1 74 d5 11 00 mov 0x11d574,%eax <== NOT EXECUTED 10d9d5: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 10d9d8: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10d9dd: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10d9e0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10d9e2: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED /* * Use eval path to evaluate the path of the symbolic link. */ result = IMFS_eval_path( 10d9e7: 51 push %ecx <== NOT EXECUTED 10d9e8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d9eb: 53 push %ebx <== NOT EXECUTED 10d9ec: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED 10d9ef: 50 push %eax <== NOT EXECUTED 10d9f0: e8 53 00 00 00 call 10da48 <== NOT EXECUTED 10d9f5: 89 c6 mov %eax,%esi <== NOT EXECUTED &jnode->info.sym_link.name[i], flags, node ); IMFS_Set_handlers( node ); 10d9f7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d9fa: e8 a1 fe ff ff call 10d8a0 <== NOT EXECUTED /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 10d9ff: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10da02: 53 push %ebx <== NOT EXECUTED 10da03: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10da06: e8 e5 fe ff ff call 10d8f0 <== NOT EXECUTED 10da0b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10da0e: 85 c0 test %eax,%eax <== NOT EXECUTED 10da10: 74 0a je 10da1c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10da12: 89 f0 mov %esi,%eax <== NOT EXECUTED 10da14: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10da17: 5b pop %ebx <== NOT EXECUTED 10da18: 5e pop %esi <== NOT EXECUTED 10da19: 5f pop %edi <== NOT EXECUTED 10da1a: c9 leave <== NOT EXECUTED 10da1b: c3 ret <== 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 ); 10da1c: e8 5f 32 00 00 call 110c80 <__errno> <== NOT EXECUTED 10da21: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10da27: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 10da2c: eb e4 jmp 10da12 <== NOT EXECUTED /* * Check for things that should never happen. */ if ( jnode->type != IMFS_SYM_LINK ) rtems_fatal_error_occurred (0xABCD0000); 10da2e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10da31: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED 10da36: e8 0d d0 ff ff call 10aa48 <== NOT EXECUTED if ( !jnode->Parent ) rtems_fatal_error_occurred( 0xBAD00000 ); 10da3b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10da3e: 68 00 00 d0 ba push $0xbad00000 <== NOT EXECUTED 10da43: e8 00 d0 ff ff call 10aa48 <== NOT EXECUTED 001102ec : int IMFS_fchmod( rtems_filesystem_location_info_t *loc, mode_t mode ) { 1102ec: 55 push %ebp <== NOT EXECUTED 1102ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1102ef: 56 push %esi <== NOT EXECUTED 1102f0: 53 push %ebx <== NOT EXECUTED 1102f1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1102f4: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *jnode; #if defined(RTEMS_POSIX_API) uid_t st_uid; #endif jnode = loc->node_access; 1102f7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1102fa: 8b 30 mov (%eax),%esi <== NOT EXECUTED /* * Verify I am the owner of the node or the super user. */ #if defined(RTEMS_POSIX_API) st_uid = geteuid(); 1102fc: e8 9b e3 ff ff call 10e69c <== NOT EXECUTED if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) 110301: 66 3b 46 3c cmp 0x3c(%esi),%ax <== NOT EXECUTED 110305: 74 05 je 11030c <== NOT EXECUTED 110307: 66 85 c0 test %ax,%ax <== NOT EXECUTED 11030a: 75 38 jne 110344 <== NOT EXECUTED #endif /* * Change only the RWX permissions on the jnode to mode. */ if ( mode & (~ (S_IRWXU | S_IRWXG | S_IRWXO ) ) ) 11030c: f7 c3 00 fe ff ff test $0xfffffe00,%ebx <== NOT EXECUTED 110312: 75 30 jne 110344 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EPERM ); jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO); jnode->st_mode |= mode; 110314: 8b 46 30 mov 0x30(%esi),%eax <== NOT EXECUTED 110317: 25 00 fe ff ff and $0xfffffe00,%eax <== NOT EXECUTED 11031c: 09 c3 or %eax,%ebx <== NOT EXECUTED 11031e: 89 5e 30 mov %ebx,0x30(%esi) <== NOT EXECUTED IMFS_update_ctime( jnode ); 110321: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 110324: 6a 00 push $0x0 <== NOT EXECUTED 110326: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 110329: 50 push %eax <== NOT EXECUTED 11032a: e8 7d e3 ff ff call 10e6ac <== NOT EXECUTED 11032f: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 110332: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 110335: 31 c0 xor %eax,%eax <== NOT EXECUTED 110337: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 11033a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11033d: 5b pop %ebx <== NOT EXECUTED 11033e: 5e pop %esi <== NOT EXECUTED 11033f: c9 leave <== NOT EXECUTED 110340: c3 ret <== NOT EXECUTED 110341: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Change only the RWX permissions on the jnode to mode. */ if ( mode & (~ (S_IRWXU | S_IRWXG | S_IRWXO ) ) ) rtems_set_errno_and_return_minus_one( EPERM ); 110344: e8 37 09 00 00 call 110c80 <__errno> <== NOT EXECUTED 110349: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 11034f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 110354: eb e4 jmp 11033a <== NOT EXECUTED 0012f6f8 : int IMFS_fcntl( int cmd, rtems_libio_t *iop ) { 12f6f8: 55 push %ebp <== NOT EXECUTED 12f6f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 12f6fb: 31 c0 xor %eax,%eax <== NOT EXECUTED 12f6fd: c9 leave <== NOT EXECUTED 12f6fe: c3 ret <== NOT EXECUTED 0012f700 : #include "imfs.h" int IMFS_fdatasync( rtems_libio_t *iop ) { 12f700: 55 push %ebp <== NOT EXECUTED 12f701: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 12f703: 31 c0 xor %eax,%eax <== NOT EXECUTED 12f705: c9 leave <== NOT EXECUTED 12f706: c3 ret <== NOT EXECUTED 0010dfc8 : IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) { 10dfc8: 55 push %ebp <== NOT EXECUTED 10dfc9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dfcb: 57 push %edi <== NOT EXECUTED 10dfcc: 56 push %esi <== NOT EXECUTED 10dfcd: 53 push %ebx <== NOT EXECUTED 10dfce: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10dfd1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* * Check for fatal errors. A NULL directory show a problem in the * the IMFS code. */ assert( directory ); 10dfd4: 85 db test %ebx,%ebx <== NOT EXECUTED 10dfd6: 74 50 je 10e028 <== NOT EXECUTED if ( !name ) 10dfd8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10dfdb: 85 c0 test %eax,%eax <== NOT EXECUTED 10dfdd: 74 3d je 10e01c <== NOT EXECUTED /* * Check for "." and ".." */ if ( !strcmp( name, dotname ) ) 10dfdf: bf 37 94 11 00 mov $0x119437,%edi <== NOT EXECUTED 10dfe4: b9 02 00 00 00 mov $0x2,%ecx <== NOT EXECUTED 10dfe9: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10dfec: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 10dfee: 75 0c jne 10dffc <== NOT EXECUTED if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10dff0: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10dff2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dff5: 5b pop %ebx <== NOT EXECUTED 10dff6: 5e pop %esi <== NOT EXECUTED 10dff7: 5f pop %edi <== NOT EXECUTED 10dff8: c9 leave <== NOT EXECUTED 10dff9: c3 ret <== NOT EXECUTED 10dffa: 66 90 xchg %ax,%ax <== NOT EXECUTED */ if ( !strcmp( name, dotname ) ) return directory; if ( !strcmp( name, dotdotname ) ) 10dffc: bf 39 94 11 00 mov $0x119439,%edi <== NOT EXECUTED 10e001: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10e006: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10e009: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 10e00b: 75 31 jne 10e03e <== NOT EXECUTED return directory->Parent; 10e00d: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10e010: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e012: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e015: 5b pop %ebx <== NOT EXECUTED 10e016: 5e pop %esi <== NOT EXECUTED 10e017: 5f pop %edi <== NOT EXECUTED 10e018: c9 leave <== NOT EXECUTED 10e019: c3 ret <== NOT EXECUTED 10e01a: 66 90 xchg %ax,%ax <== NOT EXECUTED return directory->Parent; the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; !rtems_chain_is_tail( the_chain, the_node ); 10e01c: 31 db xor %ebx,%ebx <== NOT EXECUTED if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10e01e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e020: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e023: 5b pop %ebx <== NOT EXECUTED 10e024: 5e pop %esi <== NOT EXECUTED 10e025: 5f pop %edi <== NOT EXECUTED 10e026: c9 leave <== NOT EXECUTED 10e027: c3 ret <== NOT EXECUTED /* * Check for fatal errors. A NULL directory show a problem in the * the IMFS code. */ assert( directory ); 10e028: 68 dc 93 11 00 push $0x1193dc <== NOT EXECUTED 10e02d: 68 3c 94 11 00 push $0x11943c <== NOT EXECUTED 10e032: 6a 2a push $0x2a <== NOT EXECUTED 10e034: 68 e8 93 11 00 push $0x1193e8 <== NOT EXECUTED 10e039: e8 2a 8e ff ff call 106e68 <__assert_func> <== NOT EXECUTED if ( !strcmp( name, dotdotname ) ) return directory->Parent; the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; 10e03e: 8b 7b 50 mov 0x50(%ebx),%edi <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10e041: 83 c3 54 add $0x54,%ebx <== NOT EXECUTED !rtems_chain_is_tail( the_chain, the_node ); 10e044: 39 df cmp %ebx,%edi <== NOT EXECUTED 10e046: 75 0a jne 10e052 <== NOT EXECUTED 10e048: eb d2 jmp 10e01c <== NOT EXECUTED 10e04a: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->next ) { 10e04c: 8b 3f mov (%edi),%edi <== NOT EXECUTED return directory->Parent; the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; !rtems_chain_is_tail( the_chain, the_node ); 10e04e: 39 df cmp %ebx,%edi <== NOT EXECUTED 10e050: 74 ca je 10e01c <== NOT EXECUTED the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; if ( !strcmp( name, the_jnode->name ) ) 10e052: 8d 47 0c lea 0xc(%edi),%eax <== NOT EXECUTED 10e055: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e058: 50 push %eax <== NOT EXECUTED 10e059: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10e05c: e8 c7 3c 00 00 call 111d28 <== NOT EXECUTED 10e061: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e064: 85 c0 test %eax,%eax <== NOT EXECUTED 10e066: 75 e4 jne 10e04c <== NOT EXECUTED 10e068: 89 fb mov %edi,%ebx <== NOT EXECUTED 10e06a: eb 84 jmp 10dff0 <== NOT EXECUTED 00122f4c : */ int IMFS_freenodinfo( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 122f4c: 55 push %ebp <== NOT EXECUTED 122f4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 122f4f: 31 c0 xor %eax,%eax <== NOT EXECUTED 122f51: c9 leave <== NOT EXECUTED 122f52: c3 ret <== NOT EXECUTED 00122f54 : ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 122f54: 55 push %ebp <== NOT EXECUTED 122f55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 122f57: 57 push %edi <== NOT EXECUTED 122f58: 56 push %esi <== NOT EXECUTED 122f59: 53 push %ebx <== NOT EXECUTED 122f5a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 122f5d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED /* * 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; 122f60: 8b 58 18 mov 0x18(%eax),%ebx <== NOT EXECUTED loc = temp_mt_entry->mt_fs_root; 122f63: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 122f66: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED 122f69: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 122f6c: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 122f71: 89 d7 mov %edx,%edi <== NOT EXECUTED 122f73: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* * Set this to null to indicate that it is being unmounted. */ temp_mt_entry->mt_fs_root.node_access = NULL; 122f75: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED do { next = jnode->Parent; 122f7c: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED loc.node_access = (void *)jnode; 122f7f: 89 5d e4 mov %ebx,-0x1c(%ebp) <== NOT EXECUTED IMFS_Set_handlers( &loc ); 122f82: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 122f85: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 122f88: 50 push %eax <== NOT EXECUTED 122f89: e8 96 f8 ff ff call 122824 <== NOT EXECUTED if ( jnode->type != IMFS_DIRECTORY ) { 122f8e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 122f91: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) <== NOT EXECUTED 122f95: 75 2d jne 122fc4 <== NOT EXECUTED result = IMFS_unlink( &loc ); if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { 122f97: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 122f9a: 39 43 50 cmp %eax,0x50(%ebx) <== NOT EXECUTED 122f9d: 74 3c je 122fdb <== NOT EXECUTED result = IMFS_unlink( &loc ); if (result != 0) return -1; jnode = next; } if ( jnode != NULL ) { 122f9f: 85 db test %ebx,%ebx <== NOT EXECUTED 122fa1: 74 15 je 122fb8 <== NOT EXECUTED if ( jnode->type == IMFS_DIRECTORY ) { 122fa3: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) <== NOT EXECUTED 122fa7: 75 d3 jne 122f7c <== NOT EXECUTED if ( jnode_has_children( jnode ) ) 122fa9: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 122fac: 39 43 50 cmp %eax,0x50(%ebx) <== NOT EXECUTED 122faf: 74 cb je 122f7c <== NOT EXECUTED jnode = jnode_get_first_child( jnode ); 122fb1: 8b 5b 50 mov 0x50(%ebx),%ebx <== NOT EXECUTED } } } while (jnode != NULL); 122fb4: 85 db test %ebx,%ebx <== NOT EXECUTED 122fb6: 75 c4 jne 122f7c <== NOT EXECUTED 122fb8: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 122fba: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 122fbd: 5b pop %ebx <== NOT EXECUTED 122fbe: 5e pop %esi <== NOT EXECUTED 122fbf: 5f pop %edi <== NOT EXECUTED 122fc0: c9 leave <== NOT EXECUTED 122fc1: c3 ret <== NOT EXECUTED 122fc2: 66 90 xchg %ax,%ax <== NOT EXECUTED next = jnode->Parent; loc.node_access = (void *)jnode; IMFS_Set_handlers( &loc ); if ( jnode->type != IMFS_DIRECTORY ) { result = IMFS_unlink( &loc ); 122fc4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 122fc7: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 122fca: 52 push %edx <== NOT EXECUTED 122fcb: e8 b4 7d fe ff call 10ad84 <== NOT EXECUTED if (result != 0) 122fd0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 122fd3: 85 c0 test %eax,%eax <== NOT EXECUTED 122fd5: 75 17 jne 122fee <== NOT EXECUTED return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { result = IMFS_unlink( &loc ); if (result != 0) 122fd7: 89 f3 mov %esi,%ebx <== NOT EXECUTED 122fd9: eb c4 jmp 122f9f <== NOT EXECUTED result = IMFS_unlink( &loc ); if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { result = IMFS_unlink( &loc ); 122fdb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 122fde: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 122fe1: 57 push %edi <== NOT EXECUTED 122fe2: e8 9d 7d fe ff call 10ad84 <== NOT EXECUTED if (result != 0) 122fe7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 122fea: 85 c0 test %eax,%eax <== NOT EXECUTED 122fec: 74 e9 je 122fd7 <== NOT EXECUTED if ( jnode->type == IMFS_DIRECTORY ) { if ( jnode_has_children( jnode ) ) jnode = jnode_get_first_child( jnode ); } } } while (jnode != NULL); 122fee: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 122ff3: eb c5 jmp 122fba <== NOT EXECUTED 0010e06c : IMFS_token_types IMFS_get_token( const char *path, char *token, int *token_len ) { 10e06c: 55 push %ebp <== NOT EXECUTED 10e06d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e06f: 57 push %edi <== NOT EXECUTED 10e070: 56 push %esi <== NOT EXECUTED 10e071: 53 push %ebx <== NOT EXECUTED 10e072: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e075: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10e078: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register char c; /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; 10e07b: 8a 01 mov (%ecx),%al <== NOT EXECUTED while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) { 10e07d: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 10e07f: 0f 84 99 00 00 00 je 10e11e <== NOT EXECUTED 10e085: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 10e087: 0f 84 91 00 00 00 je 10e11e <== NOT EXECUTED 10e08d: 84 c0 test %al,%al <== NOT EXECUTED 10e08f: 0f 84 a2 00 00 00 je 10e137 <== NOT EXECUTED token[i] = c; 10e095: 88 03 mov %al,(%ebx) <== NOT EXECUTED 10e097: 31 d2 xor %edx,%edx <== NOT EXECUTED 10e099: eb 06 jmp 10e0a1 <== NOT EXECUTED 10e09b: 90 nop <== NOT EXECUTED 10e09c: 88 04 13 mov %al,(%ebx,%edx,1) <== NOT EXECUTED if ( i == IMFS_NAME_MAX ) 10e09f: 74 3f je 10e0e0 <== NOT EXECUTED return IMFS_INVALID_TOKEN; if ( !IMFS_is_valid_name_char(c) ) type = IMFS_INVALID_TOKEN; c = path [++i]; 10e0a1: 42 inc %edx <== NOT EXECUTED 10e0a2: 8a 04 11 mov (%ecx,%edx,1),%al <== NOT EXECUTED /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) { 10e0a5: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 10e0a7: 74 0d je 10e0b6 <== NOT EXECUTED 10e0a9: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 10e0ab: 74 09 je 10e0b6 <== NOT EXECUTED 10e0ad: 84 c0 test %al,%al <== NOT EXECUTED 10e0af: 74 05 je 10e0b6 <== NOT EXECUTED 10e0b1: 83 fa 20 cmp $0x20,%edx <== NOT EXECUTED 10e0b4: 7e e6 jle 10e09c <== NOT EXECUTED i++; type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; } } else if (token[ i-1 ] != '\0') { 10e0b6: 80 7c 13 ff 00 cmpb $0x0,-0x1(%ebx,%edx,1) <== NOT EXECUTED 10e0bb: 75 33 jne 10e0f0 <== NOT EXECUTED /* * Set token_len to the number of characters copied. */ *token_len = i; 10e0bd: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10e0c0: 89 10 mov %edx,(%eax) <== 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 ) 10e0c2: bf b3 8e 11 00 mov $0x118eb3,%edi <== NOT EXECUTED 10e0c7: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10e0cc: 89 de mov %ebx,%esi <== NOT EXECUTED 10e0ce: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 10e0d0: 75 26 jne 10e0f8 <== NOT EXECUTED 10e0d2: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; } return type; } 10e0d7: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10e0da: 5b pop %ebx <== NOT EXECUTED 10e0db: 5e pop %esi <== NOT EXECUTED 10e0dc: 5f pop %edi <== NOT EXECUTED 10e0dd: c9 leave <== NOT EXECUTED 10e0de: c3 ret <== NOT EXECUTED 10e0df: 90 nop <== NOT EXECUTED c = path[i]; while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) { token[i] = c; if ( i == IMFS_NAME_MAX ) 10e0e0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; } return type; } 10e0e5: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10e0e8: 5b pop %ebx <== NOT EXECUTED 10e0e9: 5e pop %esi <== NOT EXECUTED 10e0ea: 5f pop %edi <== NOT EXECUTED 10e0eb: c9 leave <== NOT EXECUTED 10e0ec: c3 ret <== NOT EXECUTED 10e0ed: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; } } else if (token[ i-1 ] != '\0') { token[i] = '\0'; 10e0f0: c6 04 13 00 movb $0x0,(%ebx,%edx,1) <== NOT EXECUTED 10e0f4: eb c7 jmp 10e0bd <== NOT EXECUTED 10e0f6: 66 90 xchg %ax,%ax <== NOT EXECUTED */ if ( type == IMFS_NAME ) { if ( strcmp( token, "..") == 0 ) type = IMFS_UP_DIR; else if ( strcmp( token, "." ) == 0 ) 10e0f8: bf b4 8e 11 00 mov $0x118eb4,%edi <== NOT EXECUTED 10e0fd: b9 02 00 00 00 mov $0x2,%ecx <== NOT EXECUTED 10e102: 89 de mov %ebx,%esi <== NOT EXECUTED 10e104: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 10e106: 0f 97 c0 seta %al <== NOT EXECUTED 10e109: 0f 92 c2 setb %dl <== NOT EXECUTED 10e10c: 28 d0 sub %dl,%al <== NOT EXECUTED 10e10e: 0f be c0 movsbl %al,%eax <== NOT EXECUTED 10e111: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10e114: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10e116: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10e119: 83 c0 03 add $0x3,%eax <== NOT EXECUTED 10e11c: eb b9 jmp 10e0d7 <== NOT EXECUTED /* * Copy a seperator into token. */ if ( i == 0 ) { token[i] = c; 10e11e: 88 03 mov %al,(%ebx) <== NOT EXECUTED 10e120: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10e125: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED /* * Set token_len to the number of characters copied. */ *token_len = i; 10e12a: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10e12d: 89 11 mov %edx,(%ecx) <== NOT EXECUTED else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; } return type; } 10e12f: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10e132: 5b pop %ebx <== NOT EXECUTED 10e133: 5e pop %esi <== NOT EXECUTED 10e134: 5f pop %edi <== NOT EXECUTED 10e135: c9 leave <== NOT EXECUTED 10e136: c3 ret <== NOT EXECUTED /* * Copy a seperator into token. */ if ( i == 0 ) { token[i] = c; 10e137: c6 03 00 movb $0x0,(%ebx) <== NOT EXECUTED 10e13a: 31 d2 xor %edx,%edx <== NOT EXECUTED 10e13c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e13e: eb ea jmp 10e12a <== NOT EXECUTED 0010aa38 : */ int IMFS_initialize( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 10aa38: 55 push %ebp <== NOT EXECUTED 10aa39: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa3b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED return IMFS_initialize_support( 10aa3e: 68 00 4b 14 00 push $0x144b00 <== NOT EXECUTED 10aa43: 68 80 4b 14 00 push $0x144b80 <== NOT EXECUTED 10aa48: 68 c0 1f 14 00 push $0x141fc0 <== NOT EXECUTED 10aa4d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10aa50: e8 03 00 00 00 call 10aa58 <== NOT EXECUTED temp_mt_entry, &IMFS_ops, &IMFS_memfile_handlers, &IMFS_directory_handlers ); } 10aa55: c9 leave <== NOT EXECUTED 10aa56: c3 ret <== NOT EXECUTED 0010e140 : rtems_filesystem_mount_table_entry_t *temp_mt_entry, const rtems_filesystem_operations_table *op_table, const rtems_filesystem_file_handlers_r *memfile_handlers, const rtems_filesystem_file_handlers_r *directory_handlers ) { 10e140: 55 push %ebp <== NOT EXECUTED 10e141: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e143: 57 push %edi <== NOT EXECUTED 10e144: 56 push %esi <== NOT EXECUTED 10e145: 53 push %ebx <== NOT EXECUTED 10e146: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e149: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *jnode; /* * determine/check value for imfs_memfile_bytes_per_block */ IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block, 10e14c: 8b 0d 04 b1 11 00 mov 0x11b104,%ecx <== NOT EXECUTED * 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) { 10e152: 83 f9 10 cmp $0x10,%ecx <== NOT EXECUTED 10e155: 74 18 je 10e16f <== NOT EXECUTED 10e157: ba 20 00 00 00 mov $0x20,%edx <== NOT EXECUTED 10e15c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e15e: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 10e160: 74 0d je 10e16f <== NOT EXECUTED /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) { 10e162: d1 e2 shl %edx <== NOT EXECUTED 10e164: 40 inc %eax <== NOT EXECUTED int bit_mask; /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); 10e165: 83 f8 05 cmp $0x5,%eax <== NOT EXECUTED 10e168: 75 f4 jne 10e15e <== NOT EXECUTED 10e16a: b9 80 00 00 00 mov $0x80,%ecx <== NOT EXECUTED bit_mask <<= 1) { if (bit_mask == requested_bytes_per_block) { is_valid = true; } } *dest_bytes_per_block = ((is_valid) 10e16f: 89 0d 28 f5 11 00 mov %ecx,0x11f528 <== NOT EXECUTED * Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_node( 10e175: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e178: 6a 00 push $0x0 <== NOT EXECUTED 10e17a: 68 ed 41 00 00 push $0x41ed <== NOT EXECUTED 10e17f: 68 e6 8f 11 00 push $0x118fe6 <== NOT EXECUTED 10e184: 6a 01 push $0x1 <== NOT EXECUTED 10e186: 6a 00 push $0x0 <== NOT EXECUTED 10e188: e8 0f 20 00 00 call 11019c <== NOT EXECUTED 10e18d: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED "", ( S_IFDIR | 0755 ), NULL ); temp_mt_entry->mt_fs_root.handlers = directory_handlers; 10e190: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10e193: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED temp_mt_entry->mt_fs_root.ops = op_table; 10e196: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e199: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS; 10e19c: 8d 7b 30 lea 0x30(%ebx),%edi <== NOT EXECUTED 10e19f: be 80 98 11 00 mov $0x119880,%esi <== NOT EXECUTED 10e1a4: b9 0c 00 00 00 mov $0xc,%ecx <== NOT EXECUTED 10e1a9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* * Create custom file system data. */ fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) ); 10e1ab: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10e1ae: 6a 0c push $0xc <== NOT EXECUTED 10e1b0: 6a 01 push $0x1 <== NOT EXECUTED 10e1b2: e8 3d 03 00 00 call 10e4f4 <== NOT EXECUTED if ( !fs_info ){ 10e1b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e1ba: 85 c0 test %eax,%eax <== NOT EXECUTED 10e1bc: 74 29 je 10e1e7 <== NOT EXECUTED free(temp_mt_entry->mt_fs_root.node_access); rtems_set_errno_and_return_minus_one(ENOMEM); } temp_mt_entry->fs_info = fs_info; 10e1be: 89 43 2c mov %eax,0x2c(%ebx) <== NOT EXECUTED /* * Set st_ino for the root to 1. */ fs_info->ino_count = 1; 10e1c1: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED fs_info->memfile_handlers = memfile_handlers; 10e1c7: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10e1ca: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED fs_info->directory_handlers = directory_handlers; 10e1cd: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10e1d0: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED jnode = temp_mt_entry->mt_fs_root.node_access; jnode->st_ino = fs_info->ino_count; 10e1d3: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10e1d6: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax) <== NOT EXECUTED 10e1dd: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10e1df: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e1e2: 5b pop %ebx <== NOT EXECUTED 10e1e3: 5e pop %esi <== NOT EXECUTED 10e1e4: 5f pop %edi <== NOT EXECUTED 10e1e5: c9 leave <== NOT EXECUTED 10e1e6: c3 ret <== NOT EXECUTED /* * 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); 10e1e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e1ea: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10e1ed: e8 ae 8e ff ff call 1070a0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(ENOMEM); 10e1f2: e8 89 2a 00 00 call 110c80 <__errno> <== NOT EXECUTED 10e1f7: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10e1fd: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e202: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e205: eb d8 jmp 10e1df <== NOT EXECUTED 0010ab20 : int IMFS_link( rtems_filesystem_location_info_t *to_loc, /* IN */ rtems_filesystem_location_info_t *parent_loc, /* IN */ const char *token /* IN */ ) { 10ab20: 55 push %ebp <== NOT EXECUTED 10ab21: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ab23: 53 push %ebx <== NOT EXECUTED 10ab24: 83 ec 44 sub $0x44,%esp <== NOT EXECUTED /* * Verify this node can be linked to. */ info.hard_link.link_node = to_loc->node_access; 10ab27: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ab2a: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10ab2c: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED if ( info.hard_link.link_node->st_nlink >= LINK_MAX ) 10ab2f: 66 83 78 34 07 cmpw $0x7,0x34(%eax) <== NOT EXECUTED 10ab34: 77 56 ja 10ab8c <== NOT EXECUTED /* * Remove any separators at the end of the string. */ IMFS_get_token( token, new_name, &i ); 10ab36: 50 push %eax <== NOT EXECUTED 10ab37: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10ab3a: 50 push %eax <== NOT EXECUTED 10ab3b: 8d 5d bf lea -0x41(%ebp),%ebx <== NOT EXECUTED 10ab3e: 53 push %ebx <== NOT EXECUTED 10ab3f: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10ab42: e8 1d fe ff ff call 10a964 <== NOT EXECUTED /* * Create a new link node. */ new_node = IMFS_create_node( 10ab47: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 10ab4a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10ab4d: 68 ff a1 00 00 push $0xa1ff <== NOT EXECUTED 10ab52: 53 push %ebx <== NOT EXECUTED 10ab53: 6a 03 push $0x3 <== NOT EXECUTED 10ab55: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10ab58: e8 77 7b 01 00 call 1226d4 <== NOT EXECUTED new_name, ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if ( !new_node ) 10ab5d: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10ab60: 85 c0 test %eax,%eax <== NOT EXECUTED 10ab62: 74 3a je 10ab9e <== NOT EXECUTED /* * Increment the link count of the node being pointed to. */ info.hard_link.link_node->st_nlink++; 10ab64: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10ab67: 66 ff 40 34 incw 0x34(%eax) <== NOT EXECUTED IMFS_update_ctime( info.hard_link.link_node ); 10ab6b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ab6e: 6a 00 push $0x0 <== NOT EXECUTED 10ab70: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10ab73: 50 push %eax <== NOT EXECUTED 10ab74: e8 73 08 00 00 call 10b3ec <== NOT EXECUTED 10ab79: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10ab7c: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10ab7f: 89 50 48 mov %edx,0x48(%eax) <== NOT EXECUTED 10ab82: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ab84: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10ab87: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ab8a: c9 leave <== NOT EXECUTED 10ab8b: c3 ret <== NOT EXECUTED * Verify this node can be linked to. */ info.hard_link.link_node = to_loc->node_access; if ( info.hard_link.link_node->st_nlink >= LINK_MAX ) rtems_set_errno_and_return_minus_one( EMLINK ); 10ab8c: e8 c3 6c 02 00 call 131854 <__errno> <== NOT EXECUTED 10ab91: c7 00 1f 00 00 00 movl $0x1f,(%eax) <== NOT EXECUTED 10ab97: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ab9c: eb e9 jmp 10ab87 <== NOT EXECUTED ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if ( !new_node ) rtems_set_errno_and_return_minus_one( ENOMEM ); 10ab9e: e8 b1 6c 02 00 call 131854 <__errno> <== NOT EXECUTED 10aba3: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10aba9: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10abae: eb d7 jmp 10ab87 <== NOT EXECUTED 00129d24 : MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) { 129d24: 55 push %ebp <== NOT EXECUTED 129d25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129d27: 53 push %ebx <== NOT EXECUTED 129d28: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 129d2b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED block_p memory; block_p *block_entry_ptr; assert( the_jnode ); 129d2e: 85 c0 test %eax,%eax <== NOT EXECUTED 129d30: 74 37 je 129d69 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 129d32: 83 78 4c 05 cmpl $0x5,0x4c(%eax) <== NOT EXECUTED 129d36: 75 4a jne 129d82 <== NOT EXECUTED 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 ); 129d38: 52 push %edx <== NOT EXECUTED 129d39: 6a 01 push $0x1 <== NOT EXECUTED 129d3b: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 129d3e: 50 push %eax <== NOT EXECUTED 129d3f: e8 d4 fa ff ff call 129818 <== NOT EXECUTED 129d44: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( *block_entry_ptr ) 129d46: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129d49: 8b 00 mov (%eax),%eax <== NOT EXECUTED 129d4b: 85 c0 test %eax,%eax <== NOT EXECUTED 129d4d: 74 09 je 129d58 <== NOT EXECUTED #endif memory = memfile_alloc_block(); if ( !memory ) return 1; *block_entry_ptr = memory; 129d4f: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 129d51: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 129d54: c9 leave <== NOT EXECUTED 129d55: c3 ret <== NOT EXECUTED 129d56: 66 90 xchg %ax,%ax <== NOT EXECUTED #if 0 fprintf(stdout, "%d %p", block, block_entry_ptr ); fflush(stdout); #endif memory = memfile_alloc_block(); 129d58: e8 97 fa ff ff call 1297f4 <== NOT EXECUTED if ( !memory ) 129d5d: 85 c0 test %eax,%eax <== NOT EXECUTED 129d5f: 74 04 je 129d65 <== NOT EXECUTED return 1; *block_entry_ptr = memory; 129d61: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 129d63: eb ea jmp 129d4f <== NOT EXECUTED fprintf(stdout, "%d %p", block, block_entry_ptr ); fflush(stdout); #endif memory = memfile_alloc_block(); if ( !memory ) 129d65: b0 01 mov $0x1,%al <== NOT EXECUTED 129d67: eb e8 jmp 129d51 <== NOT EXECUTED ) { block_p memory; block_p *block_entry_ptr; assert( the_jnode ); 129d69: 68 e1 54 14 00 push $0x1454e1 <== NOT EXECUTED 129d6e: 68 39 56 14 00 push $0x145639 <== NOT EXECUTED 129d73: 68 69 01 00 00 push $0x169 <== NOT EXECUTED 129d78: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 129d7d: e8 2a 12 fe ff call 10afac <__assert_func> <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 129d82: 68 54 55 14 00 push $0x145554 <== NOT EXECUTED 129d87: 68 39 56 14 00 push $0x145639 <== NOT EXECUTED 129d8c: 68 6d 01 00 00 push $0x16d <== NOT EXECUTED 129d91: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 129d96: e8 11 12 fe ff call 10afac <__assert_func> <== NOT EXECUTED 00129d9c : MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) { 129d9c: 55 push %ebp <== NOT EXECUTED 129d9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129d9f: 57 push %edi <== NOT EXECUTED 129da0: 56 push %esi <== NOT EXECUTED 129da1: 53 push %ebx <== NOT EXECUTED 129da2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 129da5: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 129da8: 85 c9 test %ecx,%ecx <== NOT EXECUTED 129daa: 0f 84 c2 00 00 00 je 129e72 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 129db0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129db3: 83 78 4c 05 cmpl $0x5,0x4c(%eax) <== NOT EXECUTED 129db7: 0f 85 ce 00 00 00 jne 129e8b <== NOT EXECUTED if ( the_jnode->type != IMFS_MEMORY_FILE ) rtems_set_errno_and_return_minus_one( EIO ); if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE ) 129dbd: 8b 0d 90 eb 14 00 mov 0x14eb90,%ecx <== NOT EXECUTED 129dc3: 89 ca mov %ecx,%edx <== NOT EXECUTED 129dc5: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED 129dc8: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 129dcb: 0f af c2 imul %edx,%eax <== NOT EXECUTED 129dce: 40 inc %eax <== NOT EXECUTED 129dcf: 0f af c2 imul %edx,%eax <== NOT EXECUTED 129dd2: 48 dec %eax <== NOT EXECUTED 129dd3: 0f af c1 imul %ecx,%eax <== NOT EXECUTED 129dd6: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 129dd9: 0f 83 81 00 00 00 jae 129e60 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( new_length <= the_jnode->info.file.size ) 129ddf: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 129de2: 8b 5a 50 mov 0x50(%edx),%ebx <== NOT EXECUTED 129de5: 39 5d 0c cmp %ebx,0xc(%ebp) <== NOT EXECUTED 129de8: 7e 3f jle 129e29 <== NOT EXECUTED /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; 129dea: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 129ded: 99 cltd <== NOT EXECUTED 129dee: f7 f9 idiv %ecx <== NOT EXECUTED 129df0: 89 c6 mov %eax,%esi <== NOT EXECUTED old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 129df2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 129df4: 99 cltd <== NOT EXECUTED 129df5: f7 f9 idiv %ecx <== NOT EXECUTED 129df7: 89 c7 mov %eax,%edi <== NOT EXECUTED /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 129df9: 39 c6 cmp %eax,%esi <== NOT EXECUTED 129dfb: 72 23 jb 129e20 <== NOT EXECUTED 129dfd: 89 c3 mov %eax,%ebx <== NOT EXECUTED 129dff: eb 08 jmp 129e09 <== NOT EXECUTED 129e01: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 129e04: 43 inc %ebx <== NOT EXECUTED 129e05: 39 de cmp %ebx,%esi <== NOT EXECUTED 129e07: 72 17 jb 129e20 <== NOT EXECUTED if ( IMFS_memfile_addblock( the_jnode, block ) ) { 129e09: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129e0c: 53 push %ebx <== NOT EXECUTED 129e0d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 129e10: e8 0f ff ff ff call 129d24 <== NOT EXECUTED 129e15: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129e18: 85 c0 test %eax,%eax <== NOT EXECUTED 129e1a: 74 e8 je 129e04 <== NOT EXECUTED 129e1c: eb 26 jmp 129e44 <== NOT EXECUTED 129e1e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; 129e20: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 129e23: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 129e26: 89 42 50 mov %eax,0x50(%edx) <== NOT EXECUTED 129e29: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 129e2b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 129e2e: 5b pop %ebx <== NOT EXECUTED 129e2f: 5e pop %esi <== NOT EXECUTED 129e30: 5f pop %edi <== NOT EXECUTED 129e31: c9 leave <== NOT EXECUTED 129e32: c3 ret <== NOT EXECUTED 129e33: 90 nop <== NOT EXECUTED */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { if ( IMFS_memfile_addblock( the_jnode, block ) ) { for ( ; block>=old_blocks ; block-- ) { IMFS_memfile_remove_block( the_jnode, block ); 129e34: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129e37: 53 push %ebx <== NOT EXECUTED 129e38: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 129e3b: e8 bc fb ff ff call 1299fc <== 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-- ) { 129e40: 4b dec %ebx <== NOT EXECUTED 129e41: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129e44: 39 df cmp %ebx,%edi <== NOT EXECUTED 129e46: 76 ec jbe 129e34 <== NOT EXECUTED IMFS_memfile_remove_block( the_jnode, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); 129e48: e8 07 7a 00 00 call 131854 <__errno> <== NOT EXECUTED 129e4d: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 129e53: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED * Set the new length of the file. */ the_jnode->info.file.size = new_length; return 0; } 129e58: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 129e5b: 5b pop %ebx <== NOT EXECUTED 129e5c: 5e pop %esi <== NOT EXECUTED 129e5d: 5f pop %edi <== NOT EXECUTED 129e5e: c9 leave <== NOT EXECUTED 129e5f: c3 ret <== NOT EXECUTED assert( the_jnode->type == IMFS_MEMORY_FILE ); if ( the_jnode->type != IMFS_MEMORY_FILE ) rtems_set_errno_and_return_minus_one( EIO ); if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE ) rtems_set_errno_and_return_minus_one( EINVAL ); 129e60: e8 ef 79 00 00 call 131854 <__errno> <== NOT EXECUTED 129e65: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 129e6b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 129e70: eb b9 jmp 129e2b <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 129e72: 68 e1 54 14 00 push $0x1454e1 <== NOT EXECUTED 129e77: 68 4f 56 14 00 push $0x14564f <== NOT EXECUTED 129e7c: 68 31 01 00 00 push $0x131 <== NOT EXECUTED 129e81: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 129e86: e8 21 11 fe ff call 10afac <__assert_func> <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 129e8b: 68 54 55 14 00 push $0x145554 <== NOT EXECUTED 129e90: 68 4f 56 14 00 push $0x14564f <== NOT EXECUTED 129e95: 68 35 01 00 00 push $0x135 <== NOT EXECUTED 129e9a: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 129e9f: e8 08 11 fe ff call 10afac <__assert_func> <== NOT EXECUTED 00129818 : #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) { 129818: 55 push %ebp <== NOT EXECUTED 129819: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12981b: 57 push %edi <== NOT EXECUTED 12981c: 56 push %esi <== NOT EXECUTED 12981d: 53 push %ebx <== NOT EXECUTED 12981e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129821: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 129824: 85 db test %ebx,%ebx <== NOT EXECUTED 129826: 0f 84 8c 00 00 00 je 1298b8 <== NOT EXECUTED if ( !the_jnode ) return NULL; assert( the_jnode->type == IMFS_MEMORY_FILE ); 12982c: 83 7b 4c 05 cmpl $0x5,0x4c(%ebx) <== NOT EXECUTED 129830: 0f 85 9b 00 00 00 jne 1298d1 <== NOT EXECUTED /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) { 129836: 8b 35 90 eb 14 00 mov 0x14eb90,%esi <== NOT EXECUTED 12983c: c1 ee 02 shr $0x2,%esi <== NOT EXECUTED 12983f: 8d 46 ff lea -0x1(%esi),%eax <== NOT EXECUTED 129842: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 129845: 76 51 jbe 129898 <== NOT EXECUTED /* * Is the block number in the doubly indirect portion? */ if ( my_block <= LAST_DOUBLY_INDIRECT ) { 129847: 8d 4e 01 lea 0x1(%esi),%ecx <== NOT EXECUTED 12984a: 0f af ce imul %esi,%ecx <== NOT EXECUTED 12984d: 8d 41 ff lea -0x1(%ecx),%eax <== NOT EXECUTED 129850: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 129853: 0f 87 9f 00 00 00 ja 1298f8 <== NOT EXECUTED #if 0 fprintf(stdout, "(d %d) ", block ); fflush(stdout); #endif my_block -= FIRST_DOUBLY_INDIRECT; 129859: 29 75 0c sub %esi,0xc(%ebp) <== NOT EXECUTED singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 12985c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 12985f: 31 d2 xor %edx,%edx <== NOT EXECUTED 129861: f7 f6 div %esi <== NOT EXECUTED 129863: 89 d7 mov %edx,%edi <== NOT EXECUTED 129865: 89 c6 mov %eax,%esi <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; p = info->doubly_indirect; 129867: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED if ( malloc_it ) { 12986a: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 12986d: 85 c9 test %ecx,%ecx <== NOT EXECUTED 12986f: 0f 84 db 00 00 00 je 129950 <== NOT EXECUTED if ( !p ) { 129875: 85 c0 test %eax,%eax <== NOT EXECUTED 129877: 0f 84 f7 00 00 00 je 129974 <== NOT EXECUTED if ( !p ) return 0; info->doubly_indirect = p; } p1 = (block_p *)p[ doubly ]; 12987d: 8d 1c b0 lea (%eax,%esi,4),%ebx <== NOT EXECUTED 129880: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p1 ) { 129882: 85 c0 test %eax,%eax <== NOT EXECUTED 129884: 0f 84 ff 00 00 00 je 129989 <== 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 ]; 12988a: 8d 04 b8 lea (%eax,%edi,4),%eax <== NOT EXECUTED /* * This means the requested block number is out of range. */ return 0; } 12988d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 129890: 5b pop %ebx <== NOT EXECUTED 129891: 5e pop %esi <== NOT EXECUTED 129892: 5f pop %edi <== NOT EXECUTED 129893: c9 leave <== NOT EXECUTED 129894: c3 ret <== NOT EXECUTED 129895: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( my_block <= LAST_INDIRECT ) { #if 0 fprintf(stdout, "(s %d) ", block ); fflush(stdout); #endif p = info->indirect; 129898: 8b 43 54 mov 0x54(%ebx),%eax <== NOT EXECUTED if ( malloc_it ) { 12989b: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 12989e: 85 f6 test %esi,%esi <== NOT EXECUTED 1298a0: 74 48 je 1298ea <== NOT EXECUTED if ( !p ) { 1298a2: 85 c0 test %eax,%eax <== NOT EXECUTED 1298a4: 0f 84 b9 00 00 00 je 129963 <== NOT EXECUTED } if ( !p ) return 0; return &info->indirect[ my_block ]; 1298aa: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 1298ad: 8d 04 90 lea (%eax,%edx,4),%eax <== NOT EXECUTED /* * This means the requested block number is out of range. */ return 0; } 1298b0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1298b3: 5b pop %ebx <== NOT EXECUTED 1298b4: 5e pop %esi <== NOT EXECUTED 1298b5: 5f pop %edi <== NOT EXECUTED 1298b6: c9 leave <== NOT EXECUTED 1298b7: c3 ret <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 1298b8: 68 e1 54 14 00 push $0x1454e1 <== NOT EXECUTED 1298bd: 68 c4 55 14 00 push $0x1455c4 <== NOT EXECUTED 1298c2: 68 86 03 00 00 push $0x386 <== NOT EXECUTED 1298c7: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 1298cc: e8 db 16 fe ff call 10afac <__assert_func> <== NOT EXECUTED if ( !the_jnode ) return NULL; assert( the_jnode->type == IMFS_MEMORY_FILE ); 1298d1: 68 54 55 14 00 push $0x145554 <== NOT EXECUTED 1298d6: 68 c4 55 14 00 push $0x1455c4 <== NOT EXECUTED 1298db: 68 8a 03 00 00 push $0x38a <== NOT EXECUTED 1298e0: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 1298e5: e8 c2 16 fe ff call 10afac <__assert_func> <== NOT EXECUTED info->indirect = p; } return &info->indirect[ my_block ]; } if ( !p ) 1298ea: 85 c0 test %eax,%eax <== NOT EXECUTED 1298ec: 75 bc jne 1298aa <== NOT EXECUTED p2 = (block_p *)p1[ doubly ]; if ( !p ) return 0; return (block_p *)&p2[ singly ]; 1298ee: 31 c0 xor %eax,%eax <== NOT EXECUTED /* * This means the requested block number is out of range. */ return 0; } 1298f0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1298f3: 5b pop %ebx <== NOT EXECUTED 1298f4: 5e pop %esi <== NOT EXECUTED 1298f5: 5f pop %edi <== NOT EXECUTED 1298f6: c9 leave <== NOT EXECUTED 1298f7: c3 ret <== NOT EXECUTED #endif /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 1298f8: 8d 41 01 lea 0x1(%ecx),%eax <== NOT EXECUTED 1298fb: 0f af c6 imul %esi,%eax <== NOT EXECUTED 1298fe: 48 dec %eax <== NOT EXECUTED 1298ff: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 129902: 77 ea ja 1298ee <== NOT EXECUTED my_block -= FIRST_TRIPLY_INDIRECT; 129904: 29 4d 0c sub %ecx,0xc(%ebp) <== NOT EXECUTED singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 129907: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 12990a: 31 d2 xor %edx,%edx <== NOT EXECUTED 12990c: f7 f6 div %esi <== NOT EXECUTED 12990e: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; 129911: 31 d2 xor %edx,%edx <== NOT EXECUTED 129913: f7 f6 div %esi <== NOT EXECUTED 129915: 89 d7 mov %edx,%edi <== NOT EXECUTED 129917: 89 c6 mov %eax,%esi <== NOT EXECUTED doubly %= IMFS_MEMFILE_BLOCK_SLOTS; p = info->triply_indirect; 129919: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED if ( malloc_it ) { 12991c: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 12991f: 85 d2 test %edx,%edx <== NOT EXECUTED 129921: 74 7a je 12999d <== NOT EXECUTED if ( !p ) { 129923: 85 c0 test %eax,%eax <== NOT EXECUTED 129925: 0f 84 93 00 00 00 je 1299be <== NOT EXECUTED if ( !p ) return 0; info->triply_indirect = p; } p1 = (block_p *) p[ triply ]; 12992b: 8d 1c b0 lea (%eax,%esi,4),%ebx <== NOT EXECUTED 12992e: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p1 ) { 129930: 85 c0 test %eax,%eax <== NOT EXECUTED 129932: 0f 84 af 00 00 00 je 1299e7 <== NOT EXECUTED if ( !p1 ) return 0; p[ triply ] = (block_p) p1; } p2 = (block_p *)p1[ doubly ]; 129938: 8d 1c b8 lea (%eax,%edi,4),%ebx <== NOT EXECUTED 12993b: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p2 ) { 12993d: 85 c0 test %eax,%eax <== NOT EXECUTED 12993f: 0f 84 8e 00 00 00 je 1299d3 <== NOT EXECUTED p2 = memfile_alloc_block(); if ( !p2 ) return 0; p1[ doubly ] = (block_p) p2; } return (block_p *)&p2[ singly ]; 129945: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 129948: 8d 04 90 lea (%eax,%edx,4),%eax <== NOT EXECUTED 12994b: e9 3d ff ff ff jmp 12988d <== NOT EXECUTED } return (block_p *)&p1[ singly ]; } if ( !p ) 129950: 85 c0 test %eax,%eax <== NOT EXECUTED 129952: 74 9a je 1298ee <== NOT EXECUTED return 0; p = (block_p *)p[ doubly ]; 129954: 8b 04 b0 mov (%eax,%esi,4),%eax <== NOT EXECUTED if ( !p ) 129957: 85 c0 test %eax,%eax <== NOT EXECUTED 129959: 0f 85 2b ff ff ff jne 12988a <== NOT EXECUTED p2 = (block_p *)p1[ doubly ]; if ( !p ) return 0; return (block_p *)&p2[ singly ]; 12995f: 31 c0 xor %eax,%eax <== NOT EXECUTED 129961: eb 8d jmp 1298f0 <== NOT EXECUTED p = info->indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 129963: e8 8c fe ff ff call 1297f4 <== NOT EXECUTED if ( !p ) 129968: 85 c0 test %eax,%eax <== NOT EXECUTED 12996a: 74 82 je 1298ee <== NOT EXECUTED return 0; info->indirect = p; 12996c: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED 12996f: e9 36 ff ff ff jmp 1298aa <== NOT EXECUTED p = info->doubly_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 129974: e8 7b fe ff ff call 1297f4 <== NOT EXECUTED if ( !p ) 129979: 85 c0 test %eax,%eax <== NOT EXECUTED 12997b: 0f 84 6d ff ff ff je 1298ee <== NOT EXECUTED return 0; info->doubly_indirect = p; 129981: 89 43 58 mov %eax,0x58(%ebx) <== NOT EXECUTED 129984: e9 f4 fe ff ff jmp 12987d <== NOT EXECUTED } p1 = (block_p *)p[ doubly ]; if ( !p1 ) { p1 = memfile_alloc_block(); 129989: e8 66 fe ff ff call 1297f4 <== NOT EXECUTED if ( !p1 ) 12998e: 85 c0 test %eax,%eax <== NOT EXECUTED 129990: 0f 84 58 ff ff ff je 1298ee <== NOT EXECUTED return 0; p[ doubly ] = (block_p) p1; 129996: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 129998: e9 ed fe ff ff jmp 12988a <== NOT EXECUTED p1[ doubly ] = (block_p) p2; } return (block_p *)&p2[ singly ]; } if ( !p ) 12999d: 85 c0 test %eax,%eax <== NOT EXECUTED 12999f: 0f 84 49 ff ff ff je 1298ee <== 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 ]; 1299a5: 8b 14 b0 mov (%eax,%esi,4),%edx <== NOT EXECUTED if ( !p1 ) 1299a8: 85 d2 test %edx,%edx <== NOT EXECUTED 1299aa: 0f 84 3e ff ff ff je 1298ee <== NOT EXECUTED p2 = (block_p *)p1[ doubly ]; if ( !p ) return 0; return (block_p *)&p2[ singly ]; 1299b0: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1299b3: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 1299b6: 03 04 ba add (%edx,%edi,4),%eax <== NOT EXECUTED 1299b9: e9 cf fe ff ff jmp 12988d <== NOT EXECUTED p = info->triply_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 1299be: e8 31 fe ff ff call 1297f4 <== NOT EXECUTED if ( !p ) 1299c3: 85 c0 test %eax,%eax <== NOT EXECUTED 1299c5: 0f 84 23 ff ff ff je 1298ee <== NOT EXECUTED return 0; info->triply_indirect = p; 1299cb: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED 1299ce: e9 58 ff ff ff jmp 12992b <== NOT EXECUTED p[ triply ] = (block_p) p1; } p2 = (block_p *)p1[ doubly ]; if ( !p2 ) { p2 = memfile_alloc_block(); 1299d3: e8 1c fe ff ff call 1297f4 <== NOT EXECUTED if ( !p2 ) 1299d8: 85 c0 test %eax,%eax <== NOT EXECUTED 1299da: 0f 84 0e ff ff ff je 1298ee <== NOT EXECUTED return 0; p1[ doubly ] = (block_p) p2; 1299e0: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 1299e2: e9 5e ff ff ff jmp 129945 <== NOT EXECUTED info->triply_indirect = p; } p1 = (block_p *) p[ triply ]; if ( !p1 ) { p1 = memfile_alloc_block(); 1299e7: e8 08 fe ff ff call 1297f4 <== NOT EXECUTED if ( !p1 ) 1299ec: 85 c0 test %eax,%eax <== NOT EXECUTED 1299ee: 0f 84 fa fe ff ff je 1298ee <== NOT EXECUTED return 0; p[ triply ] = (block_p) p1; 1299f4: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 1299f6: e9 3d ff ff ff jmp 129938 <== NOT EXECUTED 00108698 : * using the IMFS memory file type. * */ int IMFS_memfile_maximum_size( void ) { 108698: 55 push %ebp <== NOT EXECUTED 108699: 89 e5 mov %esp,%ebp <== NOT EXECUTED return IMFS_MEMFILE_MAXIMUM_SIZE; 10869b: 8b 0d 10 65 12 00 mov 0x126510,%ecx <== NOT EXECUTED 1086a1: 89 ca mov %ecx,%edx <== NOT EXECUTED 1086a3: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED 1086a6: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 1086a9: 0f af c2 imul %edx,%eax <== NOT EXECUTED 1086ac: 40 inc %eax <== NOT EXECUTED 1086ad: 0f af c2 imul %edx,%eax <== NOT EXECUTED 1086b0: 48 dec %eax <== NOT EXECUTED 1086b1: 0f af c1 imul %ecx,%eax <== NOT EXECUTED } 1086b4: c9 leave <== NOT EXECUTED 1086b5: c3 ret <== NOT EXECUTED 0012a240 : IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) { 12a240: 55 push %ebp <== NOT EXECUTED 12a241: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12a243: 57 push %edi <== NOT EXECUTED 12a244: 56 push %esi <== NOT EXECUTED 12a245: 53 push %ebx <== NOT EXECUTED 12a246: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 12a249: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 12a24c: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 12a24f: 85 ff test %edi,%edi <== NOT EXECUTED 12a251: 0f 84 d3 01 00 00 je 12a42a <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE || 12a257: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 12a25a: 8b 48 4c mov 0x4c(%eax),%ecx <== NOT EXECUTED 12a25d: 8d 41 fb lea -0x5(%ecx),%eax <== NOT EXECUTED 12a260: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 12a263: 0f 87 da 01 00 00 ja 12a443 <== NOT EXECUTED /* * Error checks on arguments */ assert( dest ); 12a269: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 12a26c: 85 db test %ebx,%ebx <== NOT EXECUTED 12a26e: 0f 84 e8 01 00 00 je 12a45c <== NOT EXECUTED /* * If there is nothing to read, then quick exit. */ my_length = length; if ( !my_length ) 12a274: 85 f6 test %esi,%esi <== NOT EXECUTED 12a276: 0f 84 99 01 00 00 je 12a415 <== NOT EXECUTED /* * Linear files (as created from a tar file are easier to handle * than block files). */ if (the_jnode->type == IMFS_LINEAR_FILE) { 12a27c: 83 f9 06 cmp $0x6,%ecx <== NOT EXECUTED 12a27f: 0f 84 2b 01 00 00 je 12a3b0 <== NOT EXECUTED * If the last byte we are supposed to read is past the end of this * in memory file, then shorten the length to read. */ last_byte = start + length; if ( last_byte > the_jnode->info.file.size ) 12a285: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 12a288: 8b 4f 50 mov 0x50(%edi),%ecx <== NOT EXECUTED 12a28b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 12a28e: 8d 04 16 lea (%esi,%edx,1),%eax <== NOT EXECUTED 12a291: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 12a293: 0f 87 c3 00 00 00 ja 12a35c <== NOT EXECUTED 12a299: 89 75 d8 mov %esi,-0x28(%ebp) <== NOT EXECUTED /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 12a29c: 8b 1d 90 eb 14 00 mov 0x14eb90,%ebx <== NOT EXECUTED 12a2a2: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 12a2a5: 99 cltd <== NOT EXECUTED 12a2a6: f7 fb idiv %ebx <== NOT EXECUTED 12a2a8: 89 d6 mov %edx,%esi <== NOT EXECUTED 12a2aa: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 12a2ad: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED if ( start_offset ) { 12a2b0: 85 d2 test %edx,%edx <== NOT EXECUTED 12a2b2: 0f 85 b0 00 00 00 jne 12a368 <== NOT EXECUTED 12a2b8: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 12a2bb: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED 12a2be: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 12a2c5: 39 5d d8 cmp %ebx,-0x28(%ebp) <== NOT EXECUTED 12a2c8: 72 3b jb 12a305 <== NOT EXECUTED 12a2ca: 66 90 xchg %ax,%ax <== NOT EXECUTED block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 12a2cc: 52 push %edx <== NOT EXECUTED 12a2cd: 6a 00 push $0x0 <== NOT EXECUTED 12a2cf: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 12a2d2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12a2d5: e8 3e f5 ff ff call 129818 <== NOT EXECUTED assert( block_ptr ); 12a2da: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12a2dd: 85 c0 test %eax,%eax <== NOT EXECUTED 12a2df: 0f 84 17 01 00 00 je 12a3fc <== NOT EXECUTED if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); 12a2e5: 8b 30 mov (%eax),%esi <== NOT EXECUTED 12a2e7: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED 12a2ea: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 12a2ec: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED dest += to_copy; 12a2ee: 89 7d e0 mov %edi,-0x20(%ebp) <== NOT EXECUTED block++; 12a2f1: ff 45 d4 incl -0x2c(%ebp) <== NOT EXECUTED my_length -= to_copy; 12a2f4: 29 5d d8 sub %ebx,-0x28(%ebp) <== NOT EXECUTED copied += to_copy; 12a2f7: 01 5d dc add %ebx,-0x24(%ebp) <== NOT EXECUTED /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 12a2fa: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 12a2fd: 39 15 90 eb 14 00 cmp %edx,0x14eb90 <== NOT EXECUTED 12a303: 76 c7 jbe 12a2cc <== NOT EXECUTED 12a305: 8b 5d dc mov -0x24(%ebp),%ebx <== NOT EXECUTED * Phase 3: possibly the first part of one block */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); if ( my_length ) { 12a308: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 12a30b: 85 c0 test %eax,%eax <== NOT EXECUTED 12a30d: 74 26 je 12a335 <== NOT EXECUTED block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 12a30f: 50 push %eax <== NOT EXECUTED 12a310: 6a 00 push $0x0 <== NOT EXECUTED 12a312: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 12a315: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12a318: e8 fb f4 ff ff call 129818 <== NOT EXECUTED assert( block_ptr ); 12a31d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12a320: 85 c0 test %eax,%eax <== NOT EXECUTED 12a322: 0f 84 66 01 00 00 je 12a48e <== NOT EXECUTED if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); 12a328: 8b 30 mov (%eax),%esi <== NOT EXECUTED 12a32a: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED 12a32d: 8b 4d d8 mov -0x28(%ebp),%ecx <== NOT EXECUTED 12a330: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED copied += my_length; 12a332: 03 5d d8 add -0x28(%ebp),%ebx <== NOT EXECUTED } IMFS_update_atime( the_jnode ); 12a335: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12a338: 6a 00 push $0x0 <== NOT EXECUTED 12a33a: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 12a33d: 50 push %eax <== NOT EXECUTED 12a33e: e8 a9 10 fe ff call 10b3ec <== NOT EXECUTED 12a343: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 12a346: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 12a349: 89 41 40 mov %eax,0x40(%ecx) <== NOT EXECUTED return copied; 12a34c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12a34e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 12a351: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12a354: 5b pop %ebx <== NOT EXECUTED 12a355: 5e pop %esi <== NOT EXECUTED 12a356: 5f pop %edi <== NOT EXECUTED 12a357: c9 leave <== NOT EXECUTED 12a358: c3 ret <== NOT EXECUTED 12a359: 8d 76 00 lea 0x0(%esi),%esi <== 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; 12a35c: 2b 4d 0c sub 0xc(%ebp),%ecx <== NOT EXECUTED 12a35f: 89 4d d8 mov %ecx,-0x28(%ebp) <== NOT EXECUTED 12a362: e9 35 ff ff ff jmp 12a29c <== NOT EXECUTED 12a367: 90 nop <== 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 ); 12a368: 51 push %ecx <== NOT EXECUTED 12a369: 6a 00 push $0x0 <== NOT EXECUTED 12a36b: ff 75 cc pushl -0x34(%ebp) <== NOT EXECUTED 12a36e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12a371: e8 a2 f4 ff ff call 129818 <== NOT EXECUTED assert( block_ptr ); 12a376: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12a379: 85 c0 test %eax,%eax <== NOT EXECUTED 12a37b: 0f 84 f4 00 00 00 je 12a475 <== 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; 12a381: 89 da mov %ebx,%edx <== NOT EXECUTED 12a383: 29 f2 sub %esi,%edx <== NOT EXECUTED 12a385: 8b 5d d8 mov -0x28(%ebp),%ebx <== NOT EXECUTED 12a388: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 12a38a: 77 6c ja 12a3f8 <== NOT EXECUTED 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 ); 12a38c: 03 30 add (%eax),%esi <== NOT EXECUTED dest += to_copy; 12a38e: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 12a391: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 12a393: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 12a395: 89 7d e0 mov %edi,-0x20(%ebp) <== NOT EXECUTED block++; 12a398: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 12a39b: 40 inc %eax <== NOT EXECUTED 12a39c: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED my_length -= to_copy; 12a39f: 29 5d d8 sub %ebx,-0x28(%ebp) <== NOT EXECUTED 12a3a2: 89 5d dc mov %ebx,-0x24(%ebp) <== NOT EXECUTED 12a3a5: 8b 1d 90 eb 14 00 mov 0x14eb90,%ebx <== NOT EXECUTED 12a3ab: e9 15 ff ff ff jmp 12a2c5 <== NOT EXECUTED 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)) 12a3b0: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 12a3b3: 8b 5a 50 mov 0x50(%edx),%ebx <== NOT EXECUTED 12a3b6: 2b 5d 0c sub 0xc(%ebp),%ebx <== NOT EXECUTED 12a3b9: 39 f3 cmp %esi,%ebx <== NOT EXECUTED 12a3bb: 77 37 ja 12a3f4 <== NOT EXECUTED my_length = the_jnode->info.linearfile.size - start; memcpy(dest, &file_ptr[start], my_length); 12a3bd: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 12a3c0: 8b 49 54 mov 0x54(%ecx),%ecx <== NOT EXECUTED 12a3c3: 01 4d 0c add %ecx,0xc(%ebp) <== NOT EXECUTED 12a3c6: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 12a3c9: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 12a3cc: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 12a3ce: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED IMFS_update_atime( the_jnode ); 12a3d0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12a3d3: 6a 00 push $0x0 <== NOT EXECUTED 12a3d5: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 12a3d8: 50 push %eax <== NOT EXECUTED 12a3d9: e8 0e 10 fe ff call 10b3ec <== NOT EXECUTED 12a3de: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 12a3e1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 12a3e4: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED return my_length; 12a3e7: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12a3e9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } IMFS_update_atime( the_jnode ); return copied; } 12a3ec: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12a3ef: 5b pop %ebx <== NOT EXECUTED 12a3f0: 5e pop %esi <== NOT EXECUTED 12a3f1: 5f pop %edi <== NOT EXECUTED 12a3f2: c9 leave <== NOT EXECUTED 12a3f3: c3 ret <== NOT EXECUTED 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)) 12a3f4: 89 f3 mov %esi,%ebx <== NOT EXECUTED 12a3f6: eb c5 jmp 12a3bd <== 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; 12a3f8: 89 d3 mov %edx,%ebx <== NOT EXECUTED 12a3fa: eb 90 jmp 12a38c <== NOT EXECUTED */ 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 ); 12a3fc: 68 f7 54 14 00 push $0x1454f7 <== NOT EXECUTED 12a401: 68 f6 55 14 00 push $0x1455f6 <== NOT EXECUTED 12a406: 68 a5 02 00 00 push $0x2a5 <== NOT EXECUTED 12a40b: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 12a410: e8 97 0b fe ff call 10afac <__assert_func> <== 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 ); 12a415: e8 3a 74 00 00 call 131854 <__errno> <== NOT EXECUTED 12a41a: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 12a420: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12a425: e9 27 ff ff ff jmp 12a351 <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 12a42a: 68 e1 54 14 00 push $0x1454e1 <== NOT EXECUTED 12a42f: 68 f6 55 14 00 push $0x1455f6 <== NOT EXECUTED 12a434: 68 4a 02 00 00 push $0x24a <== NOT EXECUTED 12a439: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 12a43e: e8 69 0b fe ff call 10afac <__assert_func> <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE || 12a443: 68 78 55 14 00 push $0x145578 <== NOT EXECUTED 12a448: 68 f6 55 14 00 push $0x1455f6 <== NOT EXECUTED 12a44d: 68 4f 02 00 00 push $0x24f <== NOT EXECUTED 12a452: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 12a457: e8 50 0b fe ff call 10afac <__assert_func> <== NOT EXECUTED /* * Error checks on arguments */ assert( dest ); 12a45c: 68 01 55 14 00 push $0x145501 <== NOT EXECUTED 12a461: 68 f6 55 14 00 push $0x1455f6 <== NOT EXECUTED 12a466: 68 58 02 00 00 push $0x258 <== NOT EXECUTED 12a46b: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 12a470: e8 37 0b fe ff call 10afac <__assert_func> <== 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 ); 12a475: 68 f7 54 14 00 push $0x1454f7 <== NOT EXECUTED 12a47a: 68 f6 55 14 00 push $0x1455f6 <== NOT EXECUTED 12a47f: 68 94 02 00 00 push $0x294 <== NOT EXECUTED 12a484: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 12a489: e8 1e 0b fe ff call 10afac <__assert_func> <== 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 ); 12a48e: 68 f7 54 14 00 push $0x1454f7 <== NOT EXECUTED 12a493: 68 f6 55 14 00 push $0x1455f6 <== NOT EXECUTED 12a498: 68 b7 02 00 00 push $0x2b7 <== NOT EXECUTED 12a49d: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 12a4a2: e8 05 0b fe ff call 10afac <__assert_func> <== NOT EXECUTED 00129aa4 : */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) { 129aa4: 55 push %ebp <== NOT EXECUTED 129aa5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129aa7: 57 push %edi <== NOT EXECUTED 129aa8: 56 push %esi <== NOT EXECUTED 129aa9: 53 push %ebx <== NOT EXECUTED 129aaa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 129aad: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129ab0: 85 c0 test %eax,%eax <== NOT EXECUTED 129ab2: 0f 84 68 01 00 00 je 129c20 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 129ab8: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129abb: 83 78 4c 05 cmpl $0x5,0x4c(%eax) <== NOT EXECUTED 129abf: 0f 85 74 01 00 00 jne 129c39 <== 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; 129ac5: 8b 15 90 eb 14 00 mov 0x14eb90,%edx <== NOT EXECUTED 129acb: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED 129ace: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED * + triply indirect */ info = &the_jnode->info.file; if ( info->indirect ) { 129ad1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 129ad4: 8b 7e 54 mov 0x54(%esi),%edi <== NOT EXECUTED 129ad7: 85 ff test %edi,%edi <== NOT EXECUTED 129ad9: 74 12 je 129aed <== NOT EXECUTED memfile_free_blocks_in_table( &info->indirect, to_free ); 129adb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129ade: 52 push %edx <== NOT EXECUTED 129adf: 89 f0 mov %esi,%eax <== NOT EXECUTED 129ae1: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 129ae4: 50 push %eax <== NOT EXECUTED 129ae5: e8 3e ff ff ff call 129a28 <== NOT EXECUTED 129aea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if ( info->doubly_indirect ) { 129aed: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 129af0: 8b 42 58 mov 0x58(%edx),%eax <== NOT EXECUTED 129af3: 85 c0 test %eax,%eax <== NOT EXECUTED 129af5: 74 5d je 129b54 <== NOT EXECUTED for ( i=0 ; i <== NOT EXECUTED 129b04: 31 db xor %ebx,%ebx <== NOT EXECUTED 129b06: 31 d2 xor %edx,%edx <== NOT EXECUTED 129b08: eb 08 jmp 129b12 <== NOT EXECUTED 129b0a: 66 90 xchg %ax,%ax <== NOT EXECUTED 129b0c: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 129b0f: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED if ( info->doubly_indirect[i] ) { 129b12: c1 e2 02 shl $0x2,%edx <== NOT EXECUTED 129b15: 8b 34 10 mov (%eax,%edx,1),%esi <== NOT EXECUTED 129b18: 85 f6 test %esi,%esi <== NOT EXECUTED 129b1a: 74 17 je 129b33 <== NOT EXECUTED memfile_free_blocks_in_table( 129b1c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129b1f: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 129b22: 01 d0 add %edx,%eax <== NOT EXECUTED 129b24: 50 push %eax <== NOT EXECUTED 129b25: e8 fe fe ff ff call 129a28 <== NOT EXECUTED 129b2a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129b2d: 8b 0d 90 eb 14 00 mov 0x14eb90,%ecx <== NOT EXECUTED memfile_free_blocks_in_table( &info->indirect, to_free ); } if ( info->doubly_indirect ) { for ( i=0 ; i <== 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 ); 129b3f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129b42: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 129b45: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129b48: 83 c0 58 add $0x58,%eax <== NOT EXECUTED 129b4b: 50 push %eax <== NOT EXECUTED 129b4c: e8 d7 fe ff ff call 129a28 <== NOT EXECUTED 129b51: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if ( info->triply_indirect ) { 129b54: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 129b57: 8b 42 5c mov 0x5c(%edx),%eax <== NOT EXECUTED 129b5a: 85 c0 test %eax,%eax <== NOT EXECUTED 129b5c: 0f 84 b4 00 00 00 je 129c16 <== NOT EXECUTED for ( i=0 ; i <== NOT EXECUTED p = (block_p *) info->triply_indirect[i]; 129b73: 8b 30 mov (%eax),%esi <== NOT EXECUTED if ( !p ) /* ensure we have a valid pointer */ 129b75: 85 f6 test %esi,%esi <== NOT EXECUTED 129b77: 0f 84 84 00 00 00 je 129c01 <== NOT EXECUTED 129b7d: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED 129b84: 31 ff xor %edi,%edi <== NOT EXECUTED 129b86: 66 90 xchg %ax,%ax <== NOT EXECUTED break; for ( j=0 ; j <== NOT EXECUTED 129b8f: 31 db xor %ebx,%ebx <== NOT EXECUTED 129b91: 31 d2 xor %edx,%edx <== NOT EXECUTED 129b93: 90 nop <== NOT EXECUTED if ( p[j] ) { 129b94: 8d 04 95 00 00 00 00 lea 0x0(,%edx,4),%eax <== NOT EXECUTED 129b9b: 8b 14 06 mov (%esi,%eax,1),%edx <== NOT EXECUTED 129b9e: 85 d2 test %edx,%edx <== NOT EXECUTED 129ba0: 74 18 je 129bba <== NOT EXECUTED memfile_free_blocks_in_table( (block_p **)&p[j], to_free); 129ba2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129ba5: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 129ba8: 8d 04 06 lea (%esi,%eax,1),%eax <== NOT EXECUTED 129bab: 50 push %eax <== NOT EXECUTED 129bac: e8 77 fe ff ff call 129a28 <== NOT EXECUTED 129bb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129bb4: 8b 0d 90 eb 14 00 mov 0x14eb90,%ecx <== 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 if ( p[j] ) { memfile_free_blocks_in_table( (block_p **)&p[j], to_free); } } memfile_free_blocks_in_table( 129bc6: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129bc9: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 129bcc: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 129bcf: 03 7a 5c add 0x5c(%edx),%edi <== NOT EXECUTED 129bd2: 57 push %edi <== NOT EXECUTED 129bd3: e8 50 fe ff ff call 129a28 <== NOT EXECUTED memfile_free_blocks_in_table( &info->doubly_indirect, to_free ); } if ( info->triply_indirect ) { for ( i=0 ; i <== NOT EXECUTED p = (block_p *) info->triply_indirect[i]; if ( !p ) /* ensure we have a valid pointer */ 129bee: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 129bf1: c1 e7 02 shl $0x2,%edi <== NOT EXECUTED } if ( info->triply_indirect ) { for ( i=0 ; itriply_indirect[i]; 129bf4: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 129bf7: 8b 42 5c mov 0x5c(%edx),%eax <== NOT EXECUTED 129bfa: 8b 34 38 mov (%eax,%edi,1),%esi <== NOT EXECUTED if ( !p ) /* ensure we have a valid pointer */ 129bfd: 85 f6 test %esi,%esi <== NOT EXECUTED 129bff: 75 87 jne 129b88 <== NOT EXECUTED } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( 129c01: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129c04: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 129c07: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129c0a: 83 c0 5c add $0x5c,%eax <== NOT EXECUTED 129c0d: 50 push %eax <== NOT EXECUTED 129c0e: e8 15 fe ff ff call 129a28 <== NOT EXECUTED 129c13: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (block_p **)&info->triply_indirect, to_free ); } return 0; } 129c16: 31 c0 xor %eax,%eax <== NOT EXECUTED 129c18: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 129c1b: 5b pop %ebx <== NOT EXECUTED 129c1c: 5e pop %esi <== NOT EXECUTED 129c1d: 5f pop %edi <== NOT EXECUTED 129c1e: c9 leave <== NOT EXECUTED 129c1f: c3 ret <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 129c20: 68 e1 54 14 00 push $0x1454e1 <== NOT EXECUTED 129c25: 68 08 56 14 00 push $0x145608 <== NOT EXECUTED 129c2a: 68 ec 01 00 00 push $0x1ec <== NOT EXECUTED 129c2f: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 129c34: e8 73 13 fe ff call 10afac <__assert_func> <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 129c39: 68 54 55 14 00 push $0x145554 <== NOT EXECUTED 129c3e: 68 08 56 14 00 push $0x145608 <== NOT EXECUTED 129c43: 68 f0 01 00 00 push $0x1f0 <== NOT EXECUTED 129c48: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 129c4d: e8 5a 13 fe ff call 10afac <__assert_func> <== NOT EXECUTED 001299fc : MEMFILE_STATIC int IMFS_memfile_remove_block( IMFS_jnode_t *the_jnode, unsigned int block ) { 1299fc: 55 push %ebp <== NOT EXECUTED 1299fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1299ff: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED block_p *block_entry_ptr; block_p ptr; block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 129a02: 6a 00 push $0x0 <== NOT EXECUTED 129a04: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 129a07: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 129a0a: e8 09 fe ff ff call 129818 <== NOT EXECUTED ptr = *block_entry_ptr; 129a0f: 8b 10 mov (%eax),%edx <== NOT EXECUTED *block_entry_ptr = 0; 129a11: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED memfile_free_block( ptr ); 129a17: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 129a1a: e8 b9 fd ff ff call 1297d8 <== NOT EXECUTED return 1; } 129a1f: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 129a24: c9 leave <== NOT EXECUTED 129a25: c3 ret <== NOT EXECUTED 00129f4c : IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 129f4c: 55 push %ebp <== NOT EXECUTED 129f4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129f4f: 57 push %edi <== NOT EXECUTED 129f50: 56 push %esi <== NOT EXECUTED 129f51: 53 push %ebx <== NOT EXECUTED 129f52: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 129f55: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129f58: 85 c0 test %eax,%eax <== NOT EXECUTED 129f5a: 0f 84 ce 01 00 00 je 12a12e <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 129f60: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129f63: 83 78 4c 05 cmpl $0x5,0x4c(%eax) <== NOT EXECUTED 129f67: 0f 85 a8 01 00 00 jne 12a115 <== NOT EXECUTED /* * Error check arguments */ assert( source ); 129f6d: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 129f70: 85 c0 test %eax,%eax <== NOT EXECUTED 129f72: 0f 84 cf 01 00 00 je 12a147 <== NOT EXECUTED /* * If there is nothing to write, then quick exit. */ my_length = length; if ( !my_length ) 129f78: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 129f7b: 85 c0 test %eax,%eax <== NOT EXECUTED 129f7d: 0f 84 7b 01 00 00 je 12a0fe <== NOT EXECUTED /* * 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; 129f83: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 129f86: 03 45 0c add 0xc(%ebp),%eax <== NOT EXECUTED if ( last_byte > the_jnode->info.file.size ) { 129f89: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 129f8c: 3b 42 50 cmp 0x50(%edx),%eax <== NOT EXECUTED 129f8f: 0f 87 1f 01 00 00 ja 12a0b4 <== NOT EXECUTED /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 129f95: 8b 1d 90 eb 14 00 mov 0x14eb90,%ebx <== NOT EXECUTED 129f9b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 129f9e: 99 cltd <== NOT EXECUTED 129f9f: f7 fb idiv %ebx <== NOT EXECUTED 129fa1: 89 55 c0 mov %edx,-0x40(%ebp) <== NOT EXECUTED 129fa4: 89 45 bc mov %eax,-0x44(%ebp) <== NOT EXECUTED block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 129fa7: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED if ( start_offset ) { 129faa: 85 d2 test %edx,%edx <== NOT EXECUTED 129fac: 0f 85 ae 00 00 00 jne 12a060 <== NOT EXECUTED 129fb2: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 129fb5: 89 4d c0 mov %ecx,-0x40(%ebp) <== NOT EXECUTED 129fb8: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 129fbb: 89 75 e0 mov %esi,-0x20(%ebp) <== NOT EXECUTED 129fbe: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 129fc5: 39 5d c0 cmp %ebx,-0x40(%ebp) <== NOT EXECUTED 129fc8: 72 3b jb 12a005 <== NOT EXECUTED 129fca: 66 90 xchg %ax,%ax <== NOT EXECUTED block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 129fcc: 57 push %edi <== NOT EXECUTED 129fcd: 6a 00 push $0x0 <== NOT EXECUTED 129fcf: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 129fd2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 129fd5: e8 3e f8 ff ff call 129818 <== NOT EXECUTED assert( block_ptr ); 129fda: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129fdd: 85 c0 test %eax,%eax <== NOT EXECUTED 129fdf: 0f 84 00 01 00 00 je 12a0e5 <== NOT EXECUTED if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ 0 ], src, to_copy ); 129fe5: 8b 38 mov (%eax),%edi <== NOT EXECUTED src += to_copy; 129fe7: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 129fea: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 129fec: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 129fee: 89 75 e0 mov %esi,-0x20(%ebp) <== NOT EXECUTED block++; 129ff1: ff 45 d8 incl -0x28(%ebp) <== NOT EXECUTED my_length -= to_copy; 129ff4: 29 5d c0 sub %ebx,-0x40(%ebp) <== NOT EXECUTED IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 129ff7: 01 5d dc add %ebx,-0x24(%ebp) <== NOT EXECUTED /* * Phase 2: all of zero of more blocks */ to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK; while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) { 129ffa: 8b 7d c0 mov -0x40(%ebp),%edi <== NOT EXECUTED 129ffd: 39 3d 90 eb 14 00 cmp %edi,0x14eb90 <== NOT EXECUTED 12a003: 76 c7 jbe 129fcc <== NOT EXECUTED */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); to_copy = my_length; if ( my_length ) { 12a005: 8b 75 c0 mov -0x40(%ebp),%esi <== NOT EXECUTED 12a008: 85 f6 test %esi,%esi <== NOT EXECUTED 12a00a: 74 29 je 12a035 <== NOT EXECUTED block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 12a00c: 53 push %ebx <== NOT EXECUTED 12a00d: 6a 00 push $0x0 <== NOT EXECUTED 12a00f: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 12a012: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12a015: e8 fe f7 ff ff call 129818 <== NOT EXECUTED assert( block_ptr ); 12a01a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12a01d: 85 c0 test %eax,%eax <== NOT EXECUTED 12a01f: 0f 84 54 01 00 00 je 12a179 <== NOT EXECUTED if ( !block_ptr ) return copied; #if 0 fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src ); #endif memcpy( &(*block_ptr)[ 0 ], src, my_length ); 12a025: 8b 38 mov (%eax),%edi <== NOT EXECUTED 12a027: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 12a02a: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED 12a02d: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED my_length = 0; copied += to_copy; 12a02f: 8b 7d c0 mov -0x40(%ebp),%edi <== NOT EXECUTED 12a032: 01 7d dc add %edi,-0x24(%ebp) <== NOT EXECUTED } IMFS_atime_mtime_update( the_jnode ); 12a035: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12a038: 6a 00 push $0x0 <== NOT EXECUTED 12a03a: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 12a03d: 50 push %eax <== NOT EXECUTED 12a03e: e8 a9 13 fe ff call 10b3ec <== NOT EXECUTED 12a043: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 12a046: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 12a049: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED 12a04c: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED 12a04f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return copied; } 12a052: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 12a055: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12a058: 5b pop %ebx <== NOT EXECUTED 12a059: 5e pop %esi <== NOT EXECUTED 12a05a: 5f pop %edi <== NOT EXECUTED 12a05b: c9 leave <== NOT EXECUTED 12a05c: c3 ret <== NOT EXECUTED 12a05d: 8d 76 00 lea 0x0(%esi),%esi <== 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 ); 12a060: 50 push %eax <== NOT EXECUTED 12a061: 6a 00 push $0x0 <== NOT EXECUTED 12a063: ff 75 bc pushl -0x44(%ebp) <== NOT EXECUTED 12a066: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12a069: e8 aa f7 ff ff call 129818 <== NOT EXECUTED assert( block_ptr ); 12a06e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12a071: 85 c0 test %eax,%eax <== NOT EXECUTED 12a073: 0f 84 e7 00 00 00 je 12a160 <== 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; 12a079: 89 da mov %ebx,%edx <== NOT EXECUTED 12a07b: 2b 55 c0 sub -0x40(%ebp),%edx <== NOT EXECUTED 12a07e: 3b 55 14 cmp 0x14(%ebp),%edx <== NOT EXECUTED 12a081: 77 5d ja 12a0e0 <== 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 ); 12a083: 8b 38 mov (%eax),%edi <== NOT EXECUTED 12a085: 01 7d c0 add %edi,-0x40(%ebp) <== NOT EXECUTED src += to_copy; 12a088: 8b 7d c0 mov -0x40(%ebp),%edi <== NOT EXECUTED 12a08b: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 12a08e: 89 d1 mov %edx,%ecx <== NOT EXECUTED 12a090: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 12a092: 89 75 e0 mov %esi,-0x20(%ebp) <== NOT EXECUTED block++; 12a095: 8b 45 bc mov -0x44(%ebp),%eax <== NOT EXECUTED 12a098: 40 inc %eax <== NOT EXECUTED 12a099: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED my_length -= to_copy; 12a09c: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 12a09f: 29 d1 sub %edx,%ecx <== NOT EXECUTED 12a0a1: 89 4d c0 mov %ecx,-0x40(%ebp) <== NOT EXECUTED copied += to_copy; 12a0a4: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED 12a0a7: 8b 1d 90 eb 14 00 mov 0x14eb90,%ebx <== NOT EXECUTED 12a0ad: e9 13 ff ff ff jmp 129fc5 <== NOT EXECUTED 12a0b2: 66 90 xchg %ax,%ax <== NOT EXECUTED * 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 ); 12a0b4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12a0b7: 50 push %eax <== NOT EXECUTED 12a0b8: 52 push %edx <== NOT EXECUTED 12a0b9: e8 de fc ff ff call 129d9c <== NOT EXECUTED if ( status ) 12a0be: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12a0c1: 85 c0 test %eax,%eax <== NOT EXECUTED 12a0c3: 0f 84 cc fe ff ff je 129f95 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 12a0c9: e8 86 77 00 00 call 131854 <__errno> <== NOT EXECUTED 12a0ce: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 12a0d4: c7 45 dc ff ff ff ff movl $0xffffffff,-0x24(%ebp) <== NOT EXECUTED 12a0db: e9 72 ff ff ff jmp 12a052 <== 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; 12a0e0: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 12a0e3: eb 9e jmp 12a083 <== NOT EXECUTED */ 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 ); 12a0e5: 68 f7 54 14 00 push $0x1454f7 <== NOT EXECUTED 12a0ea: 68 e3 55 14 00 push $0x1455e3 <== NOT EXECUTED 12a0ef: 68 2e 03 00 00 push $0x32e <== NOT EXECUTED 12a0f4: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 12a0f9: e8 ae 0e fe ff call 10afac <__assert_func> <== 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 ); 12a0fe: e8 51 77 00 00 call 131854 <__errno> <== NOT EXECUTED 12a103: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 12a109: c7 45 dc ff ff ff ff movl $0xffffffff,-0x24(%ebp) <== NOT EXECUTED 12a110: e9 3d ff ff ff jmp 12a052 <== NOT EXECUTED assert( the_jnode ); if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 12a115: 68 54 55 14 00 push $0x145554 <== NOT EXECUTED 12a11a: 68 e3 55 14 00 push $0x1455e3 <== NOT EXECUTED 12a11f: 68 e5 02 00 00 push $0x2e5 <== NOT EXECUTED 12a124: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 12a129: e8 7e 0e fe ff call 10afac <__assert_func> <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 12a12e: 68 e1 54 14 00 push $0x1454e1 <== NOT EXECUTED 12a133: 68 e3 55 14 00 push $0x1455e3 <== NOT EXECUTED 12a138: 68 e1 02 00 00 push $0x2e1 <== NOT EXECUTED 12a13d: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 12a142: e8 65 0e fe ff call 10afac <__assert_func> <== NOT EXECUTED /* * Error check arguments */ assert( source ); 12a147: 68 2c 4e 14 00 push $0x144e2c <== NOT EXECUTED 12a14c: 68 e3 55 14 00 push $0x1455e3 <== NOT EXECUTED 12a151: 68 ed 02 00 00 push $0x2ed <== NOT EXECUTED 12a156: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 12a15b: e8 4c 0e fe ff call 10afac <__assert_func> <== 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 ); 12a160: 68 f7 54 14 00 push $0x1454f7 <== NOT EXECUTED 12a165: 68 e3 55 14 00 push $0x1455e3 <== NOT EXECUTED 12a16a: 68 1a 03 00 00 push $0x31a <== NOT EXECUTED 12a16f: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 12a174: e8 33 0e fe ff call 10afac <__assert_func> <== 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 ); 12a179: 68 f7 54 14 00 push $0x1454f7 <== NOT EXECUTED 12a17e: 68 e3 55 14 00 push $0x1455e3 <== NOT EXECUTED 12a183: 68 44 03 00 00 push $0x344 <== NOT EXECUTED 12a188: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 12a18d: e8 1a 0e fe ff call 10afac <__assert_func> <== NOT EXECUTED 0010e208 : const char *token, /* IN */ mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10e208: 55 push %ebp <== NOT EXECUTED 10e209: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e20b: 57 push %edi <== NOT EXECUTED 10e20c: 56 push %esi <== NOT EXECUTED 10e20d: 53 push %ebx <== NOT EXECUTED 10e20e: 83 ec 50 sub $0x50,%esp <== NOT EXECUTED 10e211: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10e214: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 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 ); 10e217: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10e21a: 50 push %eax <== NOT EXECUTED 10e21b: 8d 7d bf lea -0x41(%ebp),%edi <== NOT EXECUTED 10e21e: 57 push %edi <== NOT EXECUTED 10e21f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10e222: e8 45 fe ff ff call 10e06c <== NOT EXECUTED /* * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) 10e227: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e22a: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 10e22f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e232: 3d 00 40 00 00 cmp $0x4000,%eax <== NOT EXECUTED 10e237: 74 4f je 10e288 <== NOT EXECUTED type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) 10e239: 3d 00 80 00 00 cmp $0x8000,%eax <== NOT EXECUTED 10e23e: 74 40 je 10e280 <== NOT EXECUTED type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { 10e240: 3d 00 60 00 00 cmp $0x6000,%eax <== NOT EXECUTED 10e245: 74 07 je 10e24e <== NOT EXECUTED 10e247: 3d 00 20 00 00 cmp $0x2000,%eax <== NOT EXECUTED 10e24c: 75 42 jne 10e290 <== NOT EXECUTED type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); 10e24e: 89 5d e0 mov %ebx,-0x20(%ebp) <== NOT EXECUTED 10e251: 89 75 e4 mov %esi,-0x1c(%ebp) <== NOT EXECUTED 10e254: ba 02 00 00 00 mov $0x2,%edx <== NOT EXECUTED /* * Allocate and fill in an IMFS jnode */ new_node = IMFS_create_node( 10e259: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e25c: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 10e25f: 50 push %eax <== NOT EXECUTED 10e260: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10e263: 57 push %edi <== NOT EXECUTED 10e264: 52 push %edx <== NOT EXECUTED 10e265: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10e268: e8 2f 1f 00 00 call 11019c <== NOT EXECUTED new_name, mode, &info ); if ( !new_node ) 10e26d: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10e270: 85 c0 test %eax,%eax <== NOT EXECUTED 10e272: 74 2e je 10e2a2 <== NOT EXECUTED 10e274: 31 c0 xor %eax,%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); return 0; } 10e276: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e279: 5b pop %ebx <== NOT EXECUTED 10e27a: 5e pop %esi <== NOT EXECUTED 10e27b: 5f pop %edi <== NOT EXECUTED 10e27c: c9 leave <== NOT EXECUTED 10e27d: c3 ret <== NOT EXECUTED 10e27e: 66 90 xchg %ax,%ax <== NOT EXECUTED * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) 10e280: ba 05 00 00 00 mov $0x5,%edx <== NOT EXECUTED 10e285: eb d2 jmp 10e259 <== NOT EXECUTED 10e287: 90 nop <== NOT EXECUTED 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 ); 10e288: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10e28d: eb ca jmp 10e259 <== NOT EXECUTED 10e28f: 90 nop <== NOT EXECUTED 10e290: e8 eb 29 00 00 call 110c80 <__errno> <== NOT EXECUTED 10e295: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10e29b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e2a0: eb d4 jmp 10e276 <== NOT EXECUTED mode, &info ); if ( !new_node ) rtems_set_errno_and_return_minus_one( ENOMEM ); 10e2a2: e8 d9 29 00 00 call 110c80 <__errno> <== NOT EXECUTED 10e2a7: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10e2ad: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e2b2: eb c2 jmp 10e276 <== NOT EXECUTED 0010ac5c : #include int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 10ac5c: 55 push %ebp <== NOT EXECUTED 10ac5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac5f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ac62: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 10ac65: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 10ac68: 83 78 4c 01 cmpl $0x1,0x4c(%eax) <== NOT EXECUTED 10ac6c: 75 0a jne 10ac78 <== NOT EXECUTED /* * Set mt_fs pointer to point to the mount table entry for * the mounted file system. */ node->info.directory.mt_fs = mt_entry; 10ac6e: 89 50 5c mov %edx,0x5c(%eax) <== NOT EXECUTED 10ac71: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10ac73: c9 leave <== NOT EXECUTED 10ac74: c3 ret <== NOT EXECUTED 10ac75: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 10ac78: e8 d7 6b 02 00 call 131854 <__errno> <== NOT EXECUTED 10ac7d: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 10ac83: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED * the mounted file system. */ node->info.directory.mt_fs = mt_entry; return 0; } 10ac88: c9 leave <== NOT EXECUTED 10ac89: c3 ret <== NOT EXECUTED 0010e2b4 : #include "imfs.h" rtems_filesystem_node_types_t IMFS_node_type( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 10e2b4: 55 push %ebp <== NOT EXECUTED 10e2b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e2b7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e2ba: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10e2bc: 8b 40 4c mov 0x4c(%eax),%eax <== NOT EXECUTED IMFS_jnode_t *node; node = pathloc->node_access; return node->type; } 10e2bf: c9 leave <== NOT EXECUTED 10e2c0: c3 ret <== NOT EXECUTED 001086b8 : */ void IMFS_print_jnode( IMFS_jnode_t *the_jnode ) { 1086b8: 55 push %ebp <== NOT EXECUTED 1086b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1086bb: 53 push %ebx <== NOT EXECUTED 1086bc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1086bf: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED assert( the_jnode ); 1086c2: 85 db test %ebx,%ebx <== NOT EXECUTED 1086c4: 0f 84 53 01 00 00 je 10881d <== NOT EXECUTED fprintf(stdout, "%s", the_jnode->name ); 1086ca: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1086cd: a1 40 47 12 00 mov 0x124740,%eax <== NOT EXECUTED 1086d2: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1086d5: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED 1086d8: 50 push %eax <== NOT EXECUTED 1086d9: e8 6e c8 00 00 call 114f4c <== NOT EXECUTED switch( the_jnode->type ) { 1086de: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 1086e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1086e4: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 1086e7: 76 2b jbe 108714 <== NOT EXECUTED fprintf(stdout, " links not printed\n" ); assert(0); break; default: fprintf(stdout, " bad type %d\n", the_jnode->type ); 1086e9: 52 push %edx <== NOT EXECUTED 1086ea: 50 push %eax <== NOT EXECUTED 1086eb: 68 1b f0 11 00 push $0x11f01b <== NOT EXECUTED 1086f0: a1 40 47 12 00 mov 0x124740,%eax <== NOT EXECUTED 1086f5: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1086f8: e8 43 c7 00 00 call 114e40 <== NOT EXECUTED assert(0); 1086fd: 68 3b d5 11 00 push $0x11d53b <== NOT EXECUTED 108702: 68 7c f1 11 00 push $0x11f17c <== NOT EXECUTED 108707: 6a 67 push $0x67 <== NOT EXECUTED 108709: 68 64 f0 11 00 push $0x11f064 <== NOT EXECUTED 10870e: e8 c9 07 00 00 call 108edc <__assert_func> <== NOT EXECUTED 108713: 90 nop <== NOT EXECUTED ) { assert( the_jnode ); fprintf(stdout, "%s", the_jnode->name ); switch( the_jnode->type ) { 108714: ff 24 85 4c f1 11 00 jmp *0x11f14c(,%eax,4) <== NOT EXECUTED 10871b: 90 nop <== NOT EXECUTED 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)", 10871c: ff 73 54 pushl 0x54(%ebx) <== NOT EXECUTED 10871f: ff 73 50 pushl 0x50(%ebx) <== NOT EXECUTED 108722: 68 ec ef 11 00 push $0x11efec <== NOT EXECUTED 108727: a1 40 47 12 00 mov 0x124740,%eax <== NOT EXECUTED 10872c: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10872f: e8 0c c7 00 00 call 114e40 <== NOT EXECUTED 108734: 83 c4 10 add $0x10,%esp <== NOT EXECUTED default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 108737: c7 45 08 e6 f3 11 00 movl $0x11f3e6,0x8(%ebp) <== NOT EXECUTED } 10873e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 108741: c9 leave <== NOT EXECUTED default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 108742: e9 19 de 00 00 jmp 116560 <== NOT EXECUTED 108747: 90 nop <== NOT EXECUTED the_jnode->info.file.indirect, the_jnode->info.file.doubly_indirect, the_jnode->info.file.triply_indirect ); #else fprintf(stdout, " (file %" PRId32 ")", 108748: 51 push %ecx <== NOT EXECUTED 108749: ff 73 50 pushl 0x50(%ebx) <== NOT EXECUTED 10874c: 68 fb ef 11 00 push $0x11effb <== NOT EXECUTED 108751: a1 40 47 12 00 mov 0x124740,%eax <== NOT EXECUTED 108756: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 108759: e8 e2 c6 00 00 call 114e40 <== NOT EXECUTED 10875e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 108761: c7 45 08 e6 f3 11 00 movl $0x11f3e6,0x8(%ebp) <== NOT EXECUTED } 108768: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10876b: c9 leave <== NOT EXECUTED default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 10876c: e9 ef dd 00 00 jmp 116560 <== NOT EXECUTED 108771: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED fprintf(stdout, " links not printed\n" ); assert(0); break; case IMFS_SYM_LINK: fprintf(stdout, " links not printed\n" ); 108774: a1 40 47 12 00 mov 0x124740,%eax <== NOT EXECUTED 108779: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10877c: 6a 13 push $0x13 <== NOT EXECUTED 10877e: 6a 01 push $0x1 <== NOT EXECUTED 108780: 68 07 f0 11 00 push $0x11f007 <== NOT EXECUTED 108785: e8 0a d2 00 00 call 115994 <== NOT EXECUTED assert(0); 10878a: 68 3b d5 11 00 push $0x11d53b <== NOT EXECUTED 10878f: 68 7c f1 11 00 push $0x11f17c <== NOT EXECUTED 108794: 6a 62 push $0x62 <== NOT EXECUTED 108796: 68 64 f0 11 00 push $0x11f064 <== NOT EXECUTED 10879b: e8 3c 07 00 00 call 108edc <__assert_func> <== NOT EXECUTED (uint32_t)the_jnode->info.file.size ); #endif break; case IMFS_HARD_LINK: fprintf(stdout, " links not printed\n" ); 1087a0: a1 40 47 12 00 mov 0x124740,%eax <== NOT EXECUTED 1087a5: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1087a8: 6a 13 push $0x13 <== NOT EXECUTED 1087aa: 6a 01 push $0x1 <== NOT EXECUTED 1087ac: 68 07 f0 11 00 push $0x11f007 <== NOT EXECUTED 1087b1: e8 de d1 00 00 call 115994 <== NOT EXECUTED assert(0); 1087b6: 68 3b d5 11 00 push $0x11d53b <== NOT EXECUTED 1087bb: 68 7c f1 11 00 push $0x11f17c <== NOT EXECUTED 1087c0: 6a 5d push $0x5d <== NOT EXECUTED 1087c2: 68 64 f0 11 00 push $0x11f064 <== NOT EXECUTED 1087c7: e8 10 07 00 00 call 108edc <__assert_func> <== NOT EXECUTED case IMFS_DIRECTORY: fprintf(stdout, "/" ); break; case IMFS_DEVICE: fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")", 1087cc: ff 73 54 pushl 0x54(%ebx) <== NOT EXECUTED 1087cf: ff 73 50 pushl 0x50(%ebx) <== NOT EXECUTED 1087d2: 68 d9 ef 11 00 push $0x11efd9 <== NOT EXECUTED 1087d7: a1 40 47 12 00 mov 0x124740,%eax <== NOT EXECUTED 1087dc: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1087df: e8 5c c6 00 00 call 114e40 <== NOT EXECUTED 1087e4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 1087e7: c7 45 08 e6 f3 11 00 movl $0x11f3e6,0x8(%ebp) <== NOT EXECUTED } 1087ee: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1087f1: c9 leave <== NOT EXECUTED default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 1087f2: e9 69 dd 00 00 jmp 116560 <== NOT EXECUTED 1087f7: 90 nop <== NOT EXECUTED assert( the_jnode ); fprintf(stdout, "%s", the_jnode->name ); switch( the_jnode->type ) { case IMFS_DIRECTORY: fprintf(stdout, "/" ); 1087f8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1087fb: a1 40 47 12 00 mov 0x124740,%eax <== NOT EXECUTED 108800: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 108803: 6a 2f push $0x2f <== NOT EXECUTED 108805: e8 72 c6 00 00 call 114e7c <== NOT EXECUTED 10880a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 10880d: c7 45 08 e6 f3 11 00 movl $0x11f3e6,0x8(%ebp) <== NOT EXECUTED } 108814: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 108817: c9 leave <== NOT EXECUTED default: fprintf(stdout, " bad type %d\n", the_jnode->type ); assert(0); break; } puts(""); 108818: e9 43 dd 00 00 jmp 116560 <== NOT EXECUTED void IMFS_print_jnode( IMFS_jnode_t *the_jnode ) { assert( the_jnode ); 10881d: 68 cf ef 11 00 push $0x11efcf <== NOT EXECUTED 108822: 68 7c f1 11 00 push $0x11f17c <== NOT EXECUTED 108827: 6a 38 push $0x38 <== NOT EXECUTED 108829: 68 64 f0 11 00 push $0x11f064 <== NOT EXECUTED 10882e: e8 a9 06 00 00 call 108edc <__assert_func> <== NOT EXECUTED 0010ac9c : int IMFS_readlink( rtems_filesystem_location_info_t *loc, char *buf, /* OUT */ size_t bufsize ) { 10ac9c: 55 push %ebp <== NOT EXECUTED 10ac9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac9f: 57 push %edi <== NOT EXECUTED 10aca0: 56 push %esi <== NOT EXECUTED 10aca1: 53 push %ebx <== NOT EXECUTED 10aca2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aca5: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10aca8: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *node; int i; node = loc->node_access; 10acab: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10acae: 8b 18 mov (%eax),%ebx <== NOT EXECUTED if ( node->type != IMFS_SYM_LINK ) 10acb0: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx) <== NOT EXECUTED 10acb4: 75 38 jne 10acee <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); for( i=0; ((iinfo.sym_link.name[i] != '\0')); i++ ) 10acb6: 85 f6 test %esi,%esi <== NOT EXECUTED 10acb8: 74 30 je 10acea <== NOT EXECUTED 10acba: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10acbd: 8a 00 mov (%eax),%al <== NOT EXECUTED 10acbf: 84 c0 test %al,%al <== NOT EXECUTED 10acc1: 74 27 je 10acea <== NOT EXECUTED int i; node = loc->node_access; if ( node->type != IMFS_SYM_LINK ) rtems_set_errno_and_return_minus_one( EINVAL ); 10acc3: 31 d2 xor %edx,%edx <== NOT EXECUTED 10acc5: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10acc7: eb 0d jmp 10acd6 <== NOT EXECUTED 10acc9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED for( i=0; ((iinfo.sym_link.name[i] != '\0')); i++ ) 10accc: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10accf: 8a 04 10 mov (%eax,%edx,1),%al <== NOT EXECUTED 10acd2: 84 c0 test %al,%al <== NOT EXECUTED 10acd4: 74 0a je 10ace0 <== NOT EXECUTED buf[i] = node->info.sym_link.name[i]; 10acd6: 88 04 0f mov %al,(%edi,%ecx,1) <== NOT EXECUTED 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++ ) 10acd9: 42 inc %edx <== NOT EXECUTED 10acda: 89 d1 mov %edx,%ecx <== NOT EXECUTED 10acdc: 39 d6 cmp %edx,%esi <== NOT EXECUTED 10acde: 77 ec ja 10accc <== NOT EXECUTED buf[i] = node->info.sym_link.name[i]; return i; } 10ace0: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ace2: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ace5: 5b pop %ebx <== NOT EXECUTED 10ace6: 5e pop %esi <== NOT EXECUTED 10ace7: 5f pop %edi <== NOT EXECUTED 10ace8: c9 leave <== NOT EXECUTED 10ace9: c3 ret <== NOT EXECUTED 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++ ) 10acea: 31 d2 xor %edx,%edx <== NOT EXECUTED 10acec: eb f2 jmp 10ace0 <== NOT EXECUTED int i; node = loc->node_access; if ( node->type != IMFS_SYM_LINK ) rtems_set_errno_and_return_minus_one( EINVAL ); 10acee: e8 61 6b 02 00 call 131854 <__errno> <== NOT EXECUTED 10acf3: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10acf9: ba ff ff ff ff mov $0xffffffff,%edx <== NOT EXECUTED 10acfe: eb e0 jmp 10ace0 <== NOT EXECUTED 0010e2c4 : */ int IMFS_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 10e2c4: 55 push %ebp <== NOT EXECUTED 10e2c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e2c7: 56 push %esi <== NOT EXECUTED 10e2c8: 53 push %ebx <== NOT EXECUTED 10e2c9: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10e2cc: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 10e2cf: 8b 1e mov (%esi),%ebx <== NOT EXECUTED /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 10e2d1: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10e2d4: 85 c0 test %eax,%eax <== NOT EXECUTED 10e2d6: 74 13 je 10e2eb <== NOT EXECUTED 10e2d8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e2db: 53 push %ebx <== NOT EXECUTED 10e2dc: e8 d7 13 00 00 call 10f6b8 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 10e2e1: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED 10e2e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 10e2eb: 66 ff 4b 34 decw 0x34(%ebx) <== NOT EXECUTED IMFS_update_ctime( the_jnode ); 10e2ef: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e2f2: 6a 00 push $0x0 <== NOT EXECUTED 10e2f4: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10e2f7: 50 push %eax <== NOT EXECUTED 10e2f8: e8 af 03 00 00 call 10e6ac <== NOT EXECUTED 10e2fd: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10e300: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED /* * The file cannot be open and the link must be less than 1 to free. */ if ( !rtems_libio_is_file_open( the_jnode ) && (the_jnode->st_nlink < 1) ) { 10e303: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10e306: e8 59 04 00 00 call 10e764 <== NOT EXECUTED 10e30b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e30e: 85 c0 test %eax,%eax <== NOT EXECUTED 10e310: 75 26 jne 10e338 <== NOT EXECUTED 10e312: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) <== NOT EXECUTED 10e317: 75 1f jne 10e338 <== NOT EXECUTED /* * Is rtems_filesystem_current this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 10e319: 8b 15 74 d5 11 00 mov 0x11d574,%edx <== NOT EXECUTED 10e31f: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10e322: 3b 06 cmp (%esi),%eax <== NOT EXECUTED 10e324: 74 36 je 10e35c <== NOT EXECUTED /* * Free memory associated with a memory file. */ if ( the_jnode->type == IMFS_SYM_LINK ) { 10e326: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx) <== NOT EXECUTED 10e32a: 74 18 je 10e344 <== NOT EXECUTED if ( the_jnode->info.sym_link.name ) free( (void*) the_jnode->info.sym_link.name ); } free( the_jnode ); 10e32c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e32f: 53 push %ebx <== NOT EXECUTED 10e330: e8 6b 8d ff ff call 1070a0 <== NOT EXECUTED 10e335: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 10e338: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e33a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e33d: 5b pop %ebx <== NOT EXECUTED 10e33e: 5e pop %esi <== NOT EXECUTED 10e33f: c9 leave <== NOT EXECUTED 10e340: c3 ret <== NOT EXECUTED 10e341: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Free memory associated with a memory file. */ if ( the_jnode->type == IMFS_SYM_LINK ) { if ( the_jnode->info.sym_link.name ) 10e344: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10e347: 85 c0 test %eax,%eax <== NOT EXECUTED 10e349: 74 e1 je 10e32c <== NOT EXECUTED free( (void*) the_jnode->info.sym_link.name ); 10e34b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e34e: 50 push %eax <== NOT EXECUTED 10e34f: e8 4c 8d ff ff call 1070a0 <== NOT EXECUTED 10e354: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e357: eb d3 jmp 10e32c <== NOT EXECUTED 10e359: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Is rtems_filesystem_current this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) rtems_filesystem_current.node_access = NULL; 10e35c: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10e363: eb c1 jmp 10e326 <== NOT EXECUTED 0010e368 : int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 10e368: 55 push %ebp <== NOT EXECUTED 10e369: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e36b: 53 push %ebx <== NOT EXECUTED 10e36c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10e36f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *the_jnode; IMFS_device_t *io; the_jnode = loc->node_access; 10e372: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e375: 8b 08 mov (%eax),%ecx <== NOT EXECUTED switch ( the_jnode->type ) { 10e377: 8b 41 4c mov 0x4c(%ecx),%eax <== NOT EXECUTED 10e37a: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10e37d: 74 65 je 10e3e4 <== NOT EXECUTED 10e37f: 7f 1b jg 10e39c <== NOT EXECUTED 10e381: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10e384: 74 6a je 10e3f0 <== NOT EXECUTED case IMFS_SYM_LINK: buf->st_size = 0; break; default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 10e386: e8 f5 28 00 00 call 110c80 <__errno> <== NOT EXECUTED 10e38b: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10e391: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED buf->st_atime = the_jnode->stat_atime; buf->st_mtime = the_jnode->stat_mtime; buf->st_ctime = the_jnode->stat_ctime; return 0; } 10e396: 5a pop %edx <== NOT EXECUTED 10e397: 5b pop %ebx <== NOT EXECUTED 10e398: c9 leave <== NOT EXECUTED 10e399: c3 ret <== NOT EXECUTED 10e39a: 66 90 xchg %ax,%ax <== NOT EXECUTED IMFS_device_t *io; the_jnode = loc->node_access; switch ( the_jnode->type ) { 10e39c: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 10e39f: 7f e5 jg 10e386 <== NOT EXECUTED buf->st_dev = rtems_filesystem_make_dev_t( io->major, io->minor ); break; case IMFS_LINEAR_FILE: case IMFS_MEMORY_FILE: buf->st_size = the_jnode->info.file.size; 10e3a1: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 10e3a4: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( ENOTSUP ); break; } buf->st_mode = the_jnode->st_mode; 10e3a7: 8b 41 30 mov 0x30(%ecx),%eax <== NOT EXECUTED 10e3aa: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED buf->st_nlink = the_jnode->st_nlink; 10e3ad: 8b 41 34 mov 0x34(%ecx),%eax <== NOT EXECUTED 10e3b0: 66 89 43 10 mov %ax,0x10(%ebx) <== NOT EXECUTED buf->st_ino = the_jnode->st_ino; 10e3b4: 8b 41 38 mov 0x38(%ecx),%eax <== NOT EXECUTED 10e3b7: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED buf->st_uid = the_jnode->st_uid; 10e3ba: 8b 41 3c mov 0x3c(%ecx),%eax <== NOT EXECUTED 10e3bd: 66 89 43 12 mov %ax,0x12(%ebx) <== NOT EXECUTED buf->st_gid = the_jnode->st_gid; 10e3c1: 66 8b 41 3e mov 0x3e(%ecx),%ax <== NOT EXECUTED 10e3c5: 66 89 43 14 mov %ax,0x14(%ebx) <== NOT EXECUTED buf->st_atime = the_jnode->stat_atime; 10e3c9: 8b 41 40 mov 0x40(%ecx),%eax <== NOT EXECUTED 10e3cc: 89 43 24 mov %eax,0x24(%ebx) <== NOT EXECUTED buf->st_mtime = the_jnode->stat_mtime; 10e3cf: 8b 41 44 mov 0x44(%ecx),%eax <== NOT EXECUTED 10e3d2: 89 43 2c mov %eax,0x2c(%ebx) <== NOT EXECUTED buf->st_ctime = the_jnode->stat_ctime; 10e3d5: 8b 41 48 mov 0x48(%ecx),%eax <== NOT EXECUTED 10e3d8: 89 43 34 mov %eax,0x34(%ebx) <== NOT EXECUTED 10e3db: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10e3dd: 5a pop %edx <== NOT EXECUTED 10e3de: 5b pop %ebx <== NOT EXECUTED 10e3df: c9 leave <== NOT EXECUTED 10e3e0: c3 ret <== NOT EXECUTED 10e3e1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED case IMFS_MEMORY_FILE: buf->st_size = the_jnode->info.file.size; break; case IMFS_SYM_LINK: buf->st_size = 0; 10e3e4: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED 10e3eb: eb ba jmp 10e3a7 <== NOT EXECUTED 10e3ed: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED switch ( the_jnode->type ) { case IMFS_DEVICE: io = &the_jnode->info.device; buf->st_dev = rtems_filesystem_make_dev_t( io->major, io->minor ); 10e3f0: 8b 51 54 mov 0x54(%ecx),%edx <== NOT EXECUTED 10e3f3: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 10e3f6: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10e3f8: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 10e3fb: eb aa jmp 10e3a7 <== NOT EXECUTED 0010ad00 : int IMFS_symlink( rtems_filesystem_location_info_t *parent_loc, const char *link_name, const char *node_name ) { 10ad00: 55 push %ebp <== NOT EXECUTED 10ad01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad03: 53 push %ebx <== NOT EXECUTED 10ad04: 83 ec 48 sub $0x48,%esp <== NOT EXECUTED /* * Remove any separators at the end of the string. */ IMFS_get_token( node_name, new_name, &i ); 10ad07: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10ad0a: 50 push %eax <== NOT EXECUTED 10ad0b: 8d 5d c7 lea -0x39(%ebp),%ebx <== NOT EXECUTED 10ad0e: 53 push %ebx <== NOT EXECUTED 10ad0f: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10ad12: e8 4d fc ff ff call 10a964 <== NOT EXECUTED /* * Duplicate link name */ info.sym_link.name = strdup( link_name); 10ad17: 58 pop %eax <== NOT EXECUTED 10ad18: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10ad1b: e8 40 b0 02 00 call 135d60 <== NOT EXECUTED 10ad20: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED if (info.sym_link.name == NULL) { 10ad23: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad26: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad28: 74 25 je 10ad4f <== NOT EXECUTED /* * Create a new link node. */ new_node = IMFS_create_node( 10ad2a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad2d: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10ad30: 50 push %eax <== NOT EXECUTED 10ad31: 68 ff a1 00 00 push $0xa1ff <== NOT EXECUTED 10ad36: 53 push %ebx <== NOT EXECUTED 10ad37: 6a 04 push $0x4 <== NOT EXECUTED 10ad39: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ad3c: e8 93 79 01 00 call 1226d4 <== NOT EXECUTED new_name, ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if (new_node == NULL) { 10ad41: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10ad44: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad46: 74 19 je 10ad61 <== NOT EXECUTED 10ad48: 31 c0 xor %eax,%eax <== NOT EXECUTED free( info.sym_link.name); rtems_set_errno_and_return_minus_one( ENOMEM); } return 0; } 10ad4a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ad4d: c9 leave <== NOT EXECUTED 10ad4e: c3 ret <== NOT EXECUTED * Duplicate link name */ info.sym_link.name = strdup( link_name); if (info.sym_link.name == NULL) { rtems_set_errno_and_return_minus_one( ENOMEM); 10ad4f: e8 00 6b 02 00 call 131854 <__errno> <== NOT EXECUTED 10ad54: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10ad5a: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ad5f: eb e9 jmp 10ad4a <== NOT EXECUTED ( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )), &info ); if (new_node == NULL) { free( info.sym_link.name); 10ad61: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad64: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 10ad67: e8 04 06 00 00 call 10b370 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM); 10ad6c: e8 e3 6a 02 00 call 131854 <__errno> <== NOT EXECUTED 10ad71: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10ad77: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ad7c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad7f: eb c9 jmp 10ad4a <== NOT EXECUTED 0010ad84 : #include int IMFS_unlink( rtems_filesystem_location_info_t *loc /* IN */ ) { 10ad84: 55 push %ebp <== NOT EXECUTED 10ad85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad87: 57 push %edi <== NOT EXECUTED 10ad88: 56 push %esi <== NOT EXECUTED 10ad89: 53 push %ebx <== NOT EXECUTED 10ad8a: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED IMFS_jnode_t *node; rtems_filesystem_location_info_t the_link; int result = 0; node = loc->node_access; 10ad8d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ad90: 8b 18 mov (%eax),%ebx <== NOT EXECUTED /* * If this is the last last pointer to the node * free the node. */ if ( node->type == IMFS_HARD_LINK ) { 10ad92: 83 7b 4c 03 cmpl $0x3,0x4c(%ebx) <== NOT EXECUTED 10ad96: 75 51 jne 10ade9 <== NOT EXECUTED if ( !node->info.hard_link.link_node ) 10ad98: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10ad9b: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad9d: 74 62 je 10ae01 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); the_link = *loc; 10ad9f: 8d 7d dc lea -0x24(%ebp),%edi <== NOT EXECUTED 10ada2: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10ada7: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10adaa: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED the_link.node_access = node->info.hard_link.link_node; 10adac: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED IMFS_Set_handlers( &the_link ); 10adaf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10adb2: 8d 7d dc lea -0x24(%ebp),%edi <== NOT EXECUTED 10adb5: 57 push %edi <== NOT EXECUTED 10adb6: e8 69 7a 01 00 call 122824 <== NOT EXECUTED /* * If removing the last hard link to a node, then we need * to remove the node that is a link and the node itself. */ if ( node->info.hard_link.link_node->st_nlink == 1) 10adbb: 8b 53 50 mov 0x50(%ebx),%edx <== NOT EXECUTED 10adbe: 8b 42 34 mov 0x34(%edx),%eax <== NOT EXECUTED 10adc1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10adc4: 66 83 f8 01 cmp $0x1,%ax <== NOT EXECUTED 10adc8: 74 49 je 10ae13 <== NOT EXECUTED if ( result != 0 ) return -1; } else { node->info.hard_link.link_node->st_nlink --; 10adca: 48 dec %eax <== NOT EXECUTED 10adcb: 66 89 42 34 mov %ax,0x34(%edx) <== NOT EXECUTED IMFS_update_ctime( node->info.hard_link.link_node ); 10adcf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10add2: 6a 00 push $0x0 <== NOT EXECUTED 10add4: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10add7: 50 push %eax <== NOT EXECUTED 10add8: e8 0f 06 00 00 call 10b3ec <== NOT EXECUTED 10addd: 8b 53 50 mov 0x50(%ebx),%edx <== NOT EXECUTED 10ade0: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10ade3: 89 42 48 mov %eax,0x48(%edx) <== NOT EXECUTED 10ade6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Now actually free the node we were asked to free. */ result = (*loc->handlers->rmnod_h)( loc ); 10ade9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10adec: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10adef: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10adf2: 52 push %edx <== NOT EXECUTED 10adf3: ff 50 34 call *0x34(%eax) <== NOT EXECUTED 10adf6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 10adf9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10adfc: 5b pop %ebx <== NOT EXECUTED 10adfd: 5e pop %esi <== NOT EXECUTED 10adfe: 5f pop %edi <== NOT EXECUTED 10adff: c9 leave <== NOT EXECUTED 10ae00: c3 ret <== NOT EXECUTED */ if ( node->type == IMFS_HARD_LINK ) { if ( !node->info.hard_link.link_node ) rtems_set_errno_and_return_minus_one( EINVAL ); 10ae01: e8 4e 6a 02 00 call 131854 <__errno> <== NOT EXECUTED 10ae06: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10ae0c: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ae11: eb e6 jmp 10adf9 <== NOT EXECUTED * to remove the node that is a link and the node itself. */ if ( node->info.hard_link.link_node->st_nlink == 1) { result = (*the_link.handlers->rmnod_h)( &the_link ); 10ae13: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae16: 57 push %edi <== NOT EXECUTED 10ae17: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10ae1a: ff 50 34 call *0x34(%eax) <== NOT EXECUTED if ( result != 0 ) 10ae1d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae20: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae22: 74 c5 je 10ade9 <== NOT EXECUTED 10ae24: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ae29: eb ce jmp 10adf9 <== NOT EXECUTED 0010ae2c : #include int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry ) { 10ae2c: 55 push %ebp <== NOT EXECUTED 10ae2d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae2f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED IMFS_jnode_t *node; node = mt_entry->mt_point_node.node_access; 10ae32: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ae35: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) 10ae38: 83 78 4c 01 cmpl $0x1,0x4c(%eax) <== NOT EXECUTED 10ae3c: 75 12 jne 10ae50 <== NOT EXECUTED /* * Did the node indicate that there was a directory mounted here? */ if ( node->info.directory.mt_fs == NULL ) 10ae3e: 8b 50 5c mov 0x5c(%eax),%edx <== NOT EXECUTED 10ae41: 85 d2 test %edx,%edx <== NOT EXECUTED 10ae43: 74 1d je 10ae62 <== NOT EXECUTED /* * 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; 10ae45: c7 40 5c 00 00 00 00 movl $0x0,0x5c(%eax) <== NOT EXECUTED 10ae4c: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10ae4e: c9 leave <== NOT EXECUTED 10ae4f: c3 ret <== NOT EXECUTED /* * Is the node that we are mounting onto a directory node ? */ if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 10ae50: e8 ff 69 02 00 call 131854 <__errno> <== NOT EXECUTED 10ae55: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 10ae5b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED */ node->info.directory.mt_fs = NULL; return 0; } 10ae60: c9 leave <== NOT EXECUTED 10ae61: c3 ret <== 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 */ 10ae62: e8 ed 69 02 00 call 131854 <__errno> <== NOT EXECUTED 10ae67: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10ae6d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED */ node->info.directory.mt_fs = NULL; return 0; } 10ae72: c9 leave <== NOT EXECUTED 10ae73: c3 ret <== NOT EXECUTED 0010ae74 : int IMFS_utime( rtems_filesystem_location_info_t *pathloc, /* IN */ time_t actime, /* IN */ time_t modtime /* IN */ ) { 10ae74: 55 push %ebp <== NOT EXECUTED 10ae75: 89 e5 mov %esp,%ebp <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 10ae77: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ae7a: 8b 10 mov (%eax),%edx <== NOT EXECUTED the_jnode->stat_atime = actime; 10ae7c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ae7f: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED the_jnode->stat_mtime = modtime; 10ae82: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10ae85: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED return 0; } 10ae88: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ae8a: c9 leave <== NOT EXECUTED 10ae8b: c3 ret <== NOT EXECUTED 0010723c : void RTEMS_Malloc_Initialize( void *start, size_t length, size_t sbrk_amount ) { 10723c: 55 push %ebp <== NOT EXECUTED 10723d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10723f: 57 push %edi <== NOT EXECUTED 107240: 53 push %ebx <== NOT EXECUTED 107241: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED #endif /* * If configured, initialize the statistics support */ if ( rtems_malloc_statistics_helpers ) 107244: a1 04 db 11 00 mov 0x11db04,%eax <== NOT EXECUTED 107249: 85 c0 test %eax,%eax <== NOT EXECUTED 10724b: 74 02 je 10724f <== NOT EXECUTED (*rtems_malloc_statistics_helpers->initialize)(); 10724d: ff 10 call *(%eax) <== NOT EXECUTED /* * Initialize the garbage collection list to start with nothing on it. */ malloc_deferred_frees_initialize(); 10724f: e8 80 ff ff ff call 1071d4 <== NOT EXECUTED starting_address = start; /* * Initialize the optional sbrk support for extending the heap */ if (rtems_malloc_sbrk_helpers) { 107254: a1 08 db 11 00 mov 0x11db08,%eax <== NOT EXECUTED 107259: 85 c0 test %eax,%eax <== NOT EXECUTED 10725b: 74 4b je 1072a8 <== NOT EXECUTED starting_address = (*rtems_malloc_sbrk_helpers->initialize)( 10725d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107260: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 107263: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107266: ff 10 call *(%eax) <== NOT EXECUTED 107268: 89 c2 mov %eax,%edx <== NOT EXECUTED 10726a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * of the time under UNIX because zero'ing memory when it is first * given to a process eliminates the chance of a process seeing data * left over from another process. This would be a security violation. */ if ( rtems_configuration_get_do_zero_of_workspace() ) 10726d: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 107272: 80 78 28 00 cmpb $0x0,0x28(%eax) <== NOT EXECUTED 107276: 75 24 jne 10729c <== NOT EXECUTED void *starting_address, size_t size, uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); 107278: 6a 04 push $0x4 <== NOT EXECUTED 10727a: 53 push %ebx <== NOT EXECUTED 10727b: 52 push %edx <== NOT EXECUTED 10727c: 68 60 f6 11 00 push $0x11f660 <== NOT EXECUTED 107281: e8 12 41 00 00 call 10b398 <_Heap_Initialize> <== NOT EXECUTED &RTEMS_Malloc_Heap, starting_address, length, CPU_HEAP_ALIGNMENT ); if ( !status ) 107286: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107289: 85 c0 test %eax,%eax <== NOT EXECUTED 10728b: 74 20 je 1072ad <== NOT EXECUTED rtems_print_buffer( (start + length) - 48, 48 ); rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); } #endif MSBUMP(space_available, length); 10728d: 01 1d c0 f6 11 00 add %ebx,0x11f6c0 <== NOT EXECUTED } 107293: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 107296: 5b pop %ebx <== NOT EXECUTED 107297: 5f pop %edi <== NOT EXECUTED 107298: c9 leave <== NOT EXECUTED 107299: c3 ret <== NOT EXECUTED 10729a: 66 90 xchg %ax,%ax <== 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_configuration_get_do_zero_of_workspace() ) memset( starting_address, 0, length ); 10729c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10729e: 89 d7 mov %edx,%edi <== NOT EXECUTED 1072a0: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 1072a2: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 1072a4: eb d2 jmp 107278 <== NOT EXECUTED 1072a6: 66 90 xchg %ax,%ax <== NOT EXECUTED starting_address = start; /* * Initialize the optional sbrk support for extending the heap */ if (rtems_malloc_sbrk_helpers) { 1072a8: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1072ab: eb c0 jmp 10726d <== NOT EXECUTED starting_address, length, CPU_HEAP_ALIGNMENT ); if ( !status ) rtems_fatal_error_occurred( status ); 1072ad: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1072b0: 6a 00 push $0x0 <== NOT EXECUTED 1072b2: e8 91 37 00 00 call 10aa48 <== NOT EXECUTED 00109634 : static rtems_printk_plugin_t print_handler; void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) { 109634: 55 push %ebp <== NOT EXECUTED 109635: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109637: 57 push %edi <== NOT EXECUTED 109638: 56 push %esi <== NOT EXECUTED 109639: 53 push %ebx <== NOT EXECUTED 10963a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10963d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED void *high_water_mark; void *current; Stack_Control *stack; char name[5]; if ( !the_thread ) 109640: 85 db test %ebx,%ebx <== NOT EXECUTED 109642: 0f 84 c0 00 00 00 je 109708 <== NOT EXECUTED return; if ( !print_handler ) 109648: a1 78 eb 14 00 mov 0x14eb78,%eax <== NOT EXECUTED 10964d: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED 109650: 85 c0 test %eax,%eax <== NOT EXECUTED 109652: 0f 84 b0 00 00 00 je 109708 <== NOT EXECUTED /* * Obtain interrupt stack information */ if (the_thread == (Thread_Control *) -1) { 109658: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED 10965b: 0f 84 cf 00 00 00 je 109730 <== NOT EXECUTED current = 0; } else return; } else { stack = &the_thread->Start.Initial_stack; 109661: 8d bb c4 00 00 00 lea 0xc4(%ebx),%edi <== NOT EXECUTED current = (void *)_CPU_Context_Get_SP( &the_thread->Registers ); 109667: 8b 83 d8 00 00 00 mov 0xd8(%ebx),%eax <== NOT EXECUTED 10966d: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED } low = Stack_check_usable_stack_start(stack); 109670: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 109673: 8d 70 10 lea 0x10(%eax),%esi <== NOT EXECUTED size = Stack_check_usable_stack_size(stack); 109676: 8b 07 mov (%edi),%eax <== NOT EXECUTED 109678: 83 e8 10 sub $0x10,%eax <== NOT EXECUTED 10967b: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED high_water_mark = Stack_check_find_high_water_mark(low, size); 10967e: 50 push %eax <== NOT EXECUTED 10967f: 56 push %esi <== NOT EXECUTED 109680: e8 73 ff ff ff call 1095f8 <== NOT EXECUTED if ( high_water_mark ) 109685: 5a pop %edx <== NOT EXECUTED 109686: 59 pop %ecx <== NOT EXECUTED 109687: 85 c0 test %eax,%eax <== NOT EXECUTED 109689: 0f 84 dd 00 00 00 je 10976c <== NOT EXECUTED used = Stack_check_Calculate_used( low, size, high_water_mark ); 10968f: 03 75 dc add -0x24(%ebp),%esi <== NOT EXECUTED 109692: 29 c6 sub %eax,%esi <== NOT EXECUTED else used = 0; if ( the_thread ) { 109694: 85 db test %ebx,%ebx <== NOT EXECUTED 109696: 0f 84 b4 00 00 00 je 109750 <== NOT EXECUTED (*print_handler)( 10969c: 50 push %eax <== NOT EXECUTED 10969d: 8d 45 ef lea -0x11(%ebp),%eax <== NOT EXECUTED 1096a0: 50 push %eax <== NOT EXECUTED 1096a1: 6a 05 push $0x5 <== NOT EXECUTED 1096a3: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 1096a6: e8 5d 5a 00 00 call 10f108 <== NOT EXECUTED 1096ab: 50 push %eax <== NOT EXECUTED 1096ac: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 1096af: 68 95 1d 14 00 push $0x141d95 <== NOT EXECUTED 1096b4: ff 35 74 eb 14 00 pushl 0x14eb74 <== NOT EXECUTED 1096ba: ff 55 d8 call *-0x28(%ebp) <== NOT EXECUTED 1096bd: 83 c4 20 add $0x20,%esp <== NOT EXECUTED ); } else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); } (*print_handler)( 1096c0: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 1096c3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1096c6: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED 1096c9: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 1096cc: 8b 17 mov (%edi),%edx <== NOT EXECUTED 1096ce: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED 1096d2: 52 push %edx <== NOT EXECUTED 1096d3: 50 push %eax <== NOT EXECUTED 1096d4: 68 b0 1d 14 00 push $0x141db0 <== NOT EXECUTED 1096d9: ff 35 74 eb 14 00 pushl 0x14eb74 <== NOT EXECUTED 1096df: ff 15 78 eb 14 00 call *0x14eb78 <== NOT EXECUTED stack->area + stack->size - 1, current, size ); if (Stack_check_Initialized == 0) { 1096e5: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1096e8: 8b 1d 70 eb 14 00 mov 0x14eb70,%ebx <== NOT EXECUTED 1096ee: 85 db test %ebx,%ebx <== NOT EXECUTED 1096f0: 74 1e je 109710 <== NOT EXECUTED (*print_handler)( print_context, "Unavailable\n" ); } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); 1096f2: 51 push %ecx <== NOT EXECUTED 1096f3: 56 push %esi <== NOT EXECUTED 1096f4: 68 db 1d 14 00 push $0x141ddb <== NOT EXECUTED 1096f9: ff 35 74 eb 14 00 pushl 0x14eb74 <== NOT EXECUTED 1096ff: ff 15 78 eb 14 00 call *0x14eb78 <== NOT EXECUTED 109705: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 109708: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10970b: 5b pop %ebx <== NOT EXECUTED 10970c: 5e pop %esi <== NOT EXECUTED 10970d: 5f pop %edi <== NOT EXECUTED 10970e: c9 leave <== NOT EXECUTED 10970f: c3 ret <== NOT EXECUTED current, size ); if (Stack_check_Initialized == 0) { (*print_handler)( print_context, "Unavailable\n" ); 109710: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109713: 68 ce 1d 14 00 push $0x141dce <== NOT EXECUTED 109718: ff 35 74 eb 14 00 pushl 0x14eb74 <== NOT EXECUTED 10971e: ff 15 78 eb 14 00 call *0x14eb78 <== NOT EXECUTED 109724: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); } } 109727: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10972a: 5b pop %ebx <== NOT EXECUTED 10972b: 5e pop %esi <== NOT EXECUTED 10972c: 5f pop %edi <== NOT EXECUTED 10972d: c9 leave <== NOT EXECUTED 10972e: c3 ret <== NOT EXECUTED 10972f: 90 nop <== NOT EXECUTED /* * Obtain interrupt stack information */ if (the_thread == (Thread_Control *) -1) { if (Stack_check_Interrupt_stack.area) { 109730: 8b 1d 54 1d 16 00 mov 0x161d54,%ebx <== NOT EXECUTED 109736: 85 db test %ebx,%ebx <== NOT EXECUTED 109738: 74 ce je 109708 <== NOT EXECUTED stack = &Stack_check_Interrupt_stack; the_thread = 0; current = 0; } else return; 10973a: 31 db xor %ebx,%ebx <== NOT EXECUTED 10973c: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 109743: bf 50 1d 16 00 mov $0x161d50,%edi <== NOT EXECUTED 109748: e9 23 ff ff ff jmp 109670 <== NOT EXECUTED 10974d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED "0x%08" PRIx32 " %4s", the_thread->Object.id, rtems_object_get_name( the_thread->Object.id, sizeof(name), name ) ); } else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); 109750: 50 push %eax <== NOT EXECUTED 109751: 6a ff push $0xffffffff <== NOT EXECUTED 109753: 68 a2 1d 14 00 push $0x141da2 <== NOT EXECUTED 109758: ff 35 74 eb 14 00 pushl 0x14eb74 <== NOT EXECUTED 10975e: ff 55 d8 call *-0x28(%ebp) <== NOT EXECUTED 109761: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109764: e9 57 ff ff ff jmp 1096c0 <== NOT EXECUTED 109769: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED low = Stack_check_usable_stack_start(stack); size = Stack_check_usable_stack_size(stack); high_water_mark = Stack_check_find_high_water_mark(low, size); if ( high_water_mark ) 10976c: 31 f6 xor %esi,%esi 10976e: e9 21 ff ff ff jmp 109694 <== NOT EXECUTED 00109948 : /* * Stack_check_Initialize */ void Stack_check_Initialize( void ) { 109948: 55 push %ebp <== NOT EXECUTED 109949: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10994b: 57 push %edi <== NOT EXECUTED 10994c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED uint32_t *p; if (Stack_check_Initialized) 10994f: a1 70 eb 14 00 mov 0x14eb70,%eax <== NOT EXECUTED 109954: 85 c0 test %eax,%eax <== NOT EXECUTED 109956: 75 59 jne 1099b1 <== NOT EXECUTED for ( p = Stack_check_Pattern.pattern; p < &Stack_check_Pattern.pattern[PATTERN_SIZE_WORDS]; p += 4 ) { p[0] = 0xFEEDF00D; /* FEED FOOD to BAD DOG */ 109958: c7 05 40 1d 16 00 0d movl $0xfeedf00d,0x161d40 <== NOT EXECUTED 10995f: f0 ed fe <== NOT EXECUTED p[1] = 0x0BAD0D06; 109962: c7 05 44 1d 16 00 06 movl $0xbad0d06,0x161d44 <== NOT EXECUTED 109969: 0d ad 0b <== NOT EXECUTED p[2] = 0xDEADF00D; /* DEAD FOOD GOOD DOG */ 10996c: c7 05 48 1d 16 00 0d movl $0xdeadf00d,0x161d48 <== NOT EXECUTED 109973: f0 ad de <== NOT EXECUTED p[3] = 0x600D0D06; 109976: c7 05 4c 1d 16 00 06 movl $0x600d0d06,0x161d4c <== NOT EXECUTED 10997d: 0d 0d 60 <== NOT EXECUTED /* * If appropriate, setup the interrupt stack for high water testing * also. */ #if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE) if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) { 109980: 8b 3d 08 1f 16 00 mov 0x161f08,%edi <== NOT EXECUTED 109986: 85 ff test %edi,%edi <== NOT EXECUTED 109988: 74 1d je 1099a7 <== NOT EXECUTED 10998a: a1 c8 1e 16 00 mov 0x161ec8,%eax <== NOT EXECUTED 10998f: 85 c0 test %eax,%eax <== NOT EXECUTED 109991: 74 14 je 1099a7 <== NOT EXECUTED Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low; 109993: 89 3d 54 1d 16 00 mov %edi,0x161d54 <== NOT EXECUTED Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high - 109999: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10999b: 29 f9 sub %edi,%ecx <== NOT EXECUTED 10999d: 89 0d 50 1d 16 00 mov %ecx,0x161d50 <== NOT EXECUTED (char *) _CPU_Interrupt_stack_low; Stack_check_Dope_stack(&Stack_check_Interrupt_stack); 1099a3: b0 a5 mov $0xa5,%al <== NOT EXECUTED 1099a5: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED } #endif Stack_check_Initialized = 1; 1099a7: c7 05 70 eb 14 00 01 movl $0x1,0x14eb70 <== NOT EXECUTED 1099ae: 00 00 00 <== NOT EXECUTED } 1099b1: 5f pop %edi <== NOT EXECUTED 1099b2: 5f pop %edi <== NOT EXECUTED 1099b3: c9 leave <== NOT EXECUTED 1099b4: c3 ret <== NOT EXECUTED 001095f8 : */ void *Stack_check_find_high_water_mark( const void *s, size_t n ) { 1095f8: 55 push %ebp <== NOT EXECUTED 1095f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1095fb: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1095fe: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED /* * start at lower memory and find first word that does not * match pattern */ base += PATTERN_SIZE_WORDS; 109601: 8d 51 10 lea 0x10(%ecx),%edx <== NOT EXECUTED for (ebase = base + length; base < ebase; base++) 109604: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 109607: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED 10960a: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10960c: 73 1d jae 10962b <== NOT EXECUTED if (*base != U32_PATTERN) 10960e: 81 79 10 a5 a5 a5 a5 cmpl $0xa5a5a5a5,0x10(%ecx) <== NOT EXECUTED 109615: 74 0d je 109624 <== NOT EXECUTED 109617: eb 17 jmp 109630 <== NOT EXECUTED 109619: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10961c: 81 3a a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%edx) <== NOT EXECUTED 109622: 75 0c jne 109630 <== 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++) 109624: 83 c2 04 add $0x4,%edx <== NOT EXECUTED 109627: 39 d0 cmp %edx,%eax <== NOT EXECUTED 109629: 77 f1 ja 10961c <== NOT EXECUTED 10962b: 31 c0 xor %eax,%eax <== NOT EXECUTED if (*base != U32_PATTERN) return (void *) base; #endif return (void *)0; } 10962d: c9 leave <== NOT EXECUTED 10962e: c3 ret <== NOT EXECUTED 10962f: 90 nop <== NOT EXECUTED */ base += PATTERN_SIZE_WORDS; for (ebase = base + length; base < ebase; base++) if (*base != U32_PATTERN) return (void *) base; 109630: 89 d0 mov %edx,%eax <== NOT EXECUTED #endif return (void *)0; } 109632: c9 leave <== NOT EXECUTED 109633: c3 ret <== NOT EXECUTED 001097f0 : */ void Stack_check_report_blown_task( Thread_Control *running, bool pattern_ok ) { 1097f0: 55 push %ebp <== NOT EXECUTED 1097f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1097f3: 56 push %esi <== NOT EXECUTED 1097f4: 53 push %ebx <== NOT EXECUTED 1097f5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 1097f8: 8a 5d 0c mov 0xc(%ebp),%bl <== NOT EXECUTED Stack_Control *stack = &running->Start.Initial_stack; printk( 1097fb: ff 76 0c pushl 0xc(%esi) <== NOT EXECUTED 1097fe: ff 76 08 pushl 0x8(%esi) <== NOT EXECUTED 109801: 56 push %esi <== NOT EXECUTED 109802: 68 44 1e 14 00 push $0x141e44 <== NOT EXECUTED 109807: e8 68 2f 00 00 call 10c774 <== NOT EXECUTED rtems_configuration_get_user_multiprocessing_table()->node ); } #endif printk( 10980c: 8b 96 c8 00 00 00 mov 0xc8(%esi),%edx <== NOT EXECUTED 109812: 8b 86 c4 00 00 00 mov 0xc4(%esi),%eax <== NOT EXECUTED 109818: 50 push %eax <== NOT EXECUTED 109819: 8d 44 02 ff lea -0x1(%edx,%eax,1),%eax <== NOT EXECUTED 10981d: 50 push %eax <== NOT EXECUTED 10981e: 52 push %edx <== NOT EXECUTED 10981f: 68 84 1e 14 00 push $0x141e84 <== NOT EXECUTED 109824: e8 4b 2f 00 00 call 10c774 <== NOT EXECUTED stack->area, stack->area + stack->size - 1, stack->size ); if ( !pattern_ok ) { 109829: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10982c: 84 db test %bl,%bl <== NOT EXECUTED 10982e: 74 10 je 109840 <== NOT EXECUTED " Damaged pattern begins at 0x%08lx and is %d bytes long\n", (unsigned long) Stack_check_Get_pattern_area(stack), PATTERN_SIZE_BYTES); } rtems_fatal_error_occurred( 0x81 ); 109830: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109833: 68 81 00 00 00 push $0x81 <== NOT EXECUTED 109838: e8 ab 61 00 00 call 10f9e8 <== NOT EXECUTED 10983d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED stack->area + stack->size - 1, stack->size ); if ( !pattern_ok ) { printk( 109840: 51 push %ecx <== NOT EXECUTED 109841: 6a 10 push $0x10 <== NOT EXECUTED 109843: 8b 86 c8 00 00 00 mov 0xc8(%esi),%eax <== NOT EXECUTED 109849: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 10984c: 50 push %eax <== NOT EXECUTED 10984d: 68 b4 1e 14 00 push $0x141eb4 <== NOT EXECUTED 109852: e8 1d 2f 00 00 call 10c774 <== NOT EXECUTED 109857: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10985a: eb d4 jmp 109830 <== NOT EXECUTED 0010ad0c <_API_Mutex_Allocate>: #include void _API_Mutex_Allocate( API_Mutex_Control **the_mutex ) { 10ad0c: 55 push %ebp <== NOT EXECUTED 10ad0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad0f: 57 push %edi <== NOT EXECUTED 10ad10: 56 push %esi <== NOT EXECUTED 10ad11: 53 push %ebx <== NOT EXECUTED 10ad12: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED CORE_mutex_Attributes attr = { CORE_MUTEX_NESTING_IS_ERROR, FALSE, CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT, 0 }; 10ad15: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10ad18: be e8 90 11 00 mov $0x1190e8,%esi <== NOT EXECUTED 10ad1d: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10ad22: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED mutex = (API_Mutex_Control *) _Objects_Allocate( &_API_Mutex_Information ); 10ad24: 68 c0 f8 11 00 push $0x11f8c0 <== NOT EXECUTED 10ad29: e8 e6 08 00 00 call 10b614 <_Objects_Allocate> <== NOT EXECUTED 10ad2e: 89 c3 mov %eax,%ebx <== NOT EXECUTED _CORE_mutex_Initialize( &mutex->Mutex, &attr, CORE_MUTEX_UNLOCKED ); 10ad30: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ad33: 6a 01 push $0x1 <== NOT EXECUTED 10ad35: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10ad38: 50 push %eax <== NOT EXECUTED 10ad39: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10ad3c: 50 push %eax <== NOT EXECUTED 10ad3d: e8 22 02 00 00 call 10af64 <_CORE_mutex_Initialize> <== NOT EXECUTED 10ad42: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 10ad46: a1 dc f8 11 00 mov 0x11f8dc,%eax <== NOT EXECUTED 10ad4b: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10ad4e: c7 43 0c 01 00 00 00 movl $0x1,0xc(%ebx) <== NOT EXECUTED _Objects_Open_u32( &_API_Mutex_Information, &mutex->Object, 1 ); *the_mutex = mutex; 10ad55: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ad58: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10ad5a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10ad5d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ad60: 5b pop %ebx <== NOT EXECUTED 10ad61: 5e pop %esi <== NOT EXECUTED 10ad62: 5f pop %edi <== NOT EXECUTED 10ad63: c9 leave <== NOT EXECUTED 10ad64: c3 ret <== NOT EXECUTED 0010ad8c <_API_Mutex_Initialization>: #include void _API_Mutex_Initialization( uint32_t maximum_mutexes ) { 10ad8c: 55 push %ebp <== NOT EXECUTED 10ad8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ad92: 6a 00 push $0x0 <== NOT EXECUTED 10ad94: 6a 00 push $0x0 <== NOT EXECUTED 10ad96: 6a 74 push $0x74 <== NOT EXECUTED 10ad98: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ad9b: 6a 02 push $0x2 <== NOT EXECUTED 10ad9d: 6a 01 push $0x1 <== NOT EXECUTED 10ad9f: 68 c0 f8 11 00 push $0x11f8c0 <== NOT EXECUTED 10ada4: e8 c3 0d 00 00 call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10ada9: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , TRUE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10adac: c9 leave <== NOT EXECUTED 10adad: c3 ret <== NOT EXECUTED 0010ad68 <_API_Mutex_Lock>: #include void _API_Mutex_Lock( API_Mutex_Control *the_mutex ) { 10ad68: 55 push %ebp <== NOT EXECUTED 10ad69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad6b: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10ad6e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10ad71: 9c pushf <== NOT EXECUTED 10ad72: fa cli <== NOT EXECUTED 10ad73: 5a pop %edx <== NOT EXECUTED _CORE_mutex_Seize( 10ad74: 52 push %edx <== NOT EXECUTED 10ad75: 6a 00 push $0x0 <== NOT EXECUTED 10ad77: 6a 01 push $0x1 <== NOT EXECUTED 10ad79: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10ad7c: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10ad7f: 50 push %eax <== NOT EXECUTED 10ad80: e8 d7 02 00 00 call 10b05c <_CORE_mutex_Seize> <== NOT EXECUTED 10ad85: 83 c4 20 add $0x20,%esp <== NOT EXECUTED the_mutex->Object.id, TRUE, 0, level ); } 10ad88: c9 leave <== NOT EXECUTED 10ad89: c3 ret <== NOT EXECUTED 0010adb0 <_API_Mutex_Unlock>: #include void _API_Mutex_Unlock( API_Mutex_Control *the_mutex ) { 10adb0: 55 push %ebp <== NOT EXECUTED 10adb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10adb3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10adb6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10adb9: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10adbe: 40 inc %eax <== NOT EXECUTED 10adbf: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED _Thread_Disable_dispatch(); _CORE_mutex_Surrender( 10adc4: 6a 00 push $0x0 <== NOT EXECUTED 10adc6: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 10adc9: 83 c2 10 add $0x10,%edx <== NOT EXECUTED 10adcc: 52 push %edx <== NOT EXECUTED 10adcd: e8 26 03 00 00 call 10b0f8 <_CORE_mutex_Surrender> <== NOT EXECUTED &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 10add2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10add5: c9 leave <== NOT EXECUTED _CORE_mutex_Surrender( &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 10add6: e9 71 15 00 00 jmp 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED 0010acf4 <_API_extensions_Add>: */ void _API_extensions_Add( API_extensions_Control *the_extension ) { 10acf4: 55 push %ebp <== NOT EXECUTED 10acf5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10acf7: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED _Chain_Append( &_API_extensions_List, &the_extension->Node ); 10acfa: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10acfd: 68 18 fa 11 00 push $0x11fa18 <== NOT EXECUTED 10ad02: e8 d5 00 00 00 call 10addc <_Chain_Append> <== NOT EXECUTED 10ad07: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10ad0a: c9 leave <== NOT EXECUTED 10ad0b: c3 ret <== NOT EXECUTED 0010ac34 <_API_extensions_Initialization>: * * _API_extensions_Initialization */ void _API_extensions_Initialization( void ) { 10ac34: 55 push %ebp <== NOT EXECUTED 10ac35: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac37: c7 05 18 fa 11 00 1c movl $0x11fa1c,0x11fa18 <== NOT EXECUTED 10ac3e: fa 11 00 <== NOT EXECUTED 10ac41: c7 05 1c fa 11 00 00 movl $0x0,0x11fa1c <== NOT EXECUTED 10ac48: 00 00 00 <== NOT EXECUTED 10ac4b: c7 05 20 fa 11 00 18 movl $0x11fa18,0x11fa20 <== NOT EXECUTED 10ac52: fa 11 00 <== NOT EXECUTED _Chain_Initialize_empty( &_API_extensions_List ); } 10ac55: c9 leave <== NOT EXECUTED 10ac56: c3 ret <== NOT EXECUTED 0010ac88 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 10ac88: 55 push %ebp <== NOT EXECUTED 10ac89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac8b: 53 push %ebx <== NOT EXECUTED 10ac8c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10ac8f: 8b 1d 18 fa 11 00 mov 0x11fa18,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10ac95: 81 fb 1c fa 11 00 cmp $0x11fa1c,%ebx <== NOT EXECUTED 10ac9b: 74 16 je 10acb3 <_API_extensions_Run_postdriver+0x2b> <== NOT EXECUTED 10ac9d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) 10aca0: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10aca3: 85 c0 test %eax,%eax <== NOT EXECUTED 10aca5: 74 02 je 10aca9 <_API_extensions_Run_postdriver+0x21> <== NOT EXECUTED (*the_extension->postdriver_hook)(); 10aca7: ff d0 call *%eax <== 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 ) { 10aca9: 8b 1b mov (%ebx),%ebx <== 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 ) ; 10acab: 81 fb 1c fa 11 00 cmp $0x11fa1c,%ebx <== NOT EXECUTED 10acb1: 75 ed jne 10aca0 <_API_extensions_Run_postdriver+0x18> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) (*the_extension->postdriver_hook)(); } } 10acb3: 5a pop %edx <== NOT EXECUTED 10acb4: 5b pop %ebx <== NOT EXECUTED 10acb5: c9 leave <== NOT EXECUTED 10acb6: c3 ret <== NOT EXECUTED 0010acb8 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 10acb8: 55 push %ebp <== NOT EXECUTED 10acb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10acbb: 53 push %ebx <== NOT EXECUTED 10acbc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10acbf: 8b 1d 18 fa 11 00 mov 0x11fa18,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10acc5: 81 fb 1c fa 11 00 cmp $0x11fa1c,%ebx <== NOT EXECUTED 10accb: 74 22 je 10acef <_API_extensions_Run_postswitch+0x37> <== NOT EXECUTED 10accd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) 10acd0: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10acd3: 85 c0 test %eax,%eax <== NOT EXECUTED 10acd5: 74 0e je 10ace5 <_API_extensions_Run_postswitch+0x2d> <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 10acd7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10acda: ff 35 7c f8 11 00 pushl 0x11f87c <== NOT EXECUTED 10ace0: ff d0 call *%eax <== NOT EXECUTED 10ace2: 83 c4 10 add $0x10,%esp <== 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 ) { 10ace5: 8b 1b mov (%ebx),%ebx <== 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 ) ; 10ace7: 81 fb 1c fa 11 00 cmp $0x11fa1c,%ebx <== NOT EXECUTED 10aced: 75 e1 jne 10acd0 <_API_extensions_Run_postswitch+0x18> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) (*the_extension->postswitch_hook)( _Thread_Executing ); } } 10acef: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10acf2: c9 leave <== NOT EXECUTED 10acf3: c3 ret <== NOT EXECUTED 0010ac58 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 10ac58: 55 push %ebp <== NOT EXECUTED 10ac59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac5b: 53 push %ebx <== NOT EXECUTED 10ac5c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10ac5f: 8b 1d 18 fa 11 00 mov 0x11fa18,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10ac65: 81 fb 1c fa 11 00 cmp $0x11fa1c,%ebx <== NOT EXECUTED 10ac6b: 74 16 je 10ac83 <_API_extensions_Run_predriver+0x2b> <== NOT EXECUTED 10ac6d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) 10ac70: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10ac73: 85 c0 test %eax,%eax <== NOT EXECUTED 10ac75: 74 02 je 10ac79 <_API_extensions_Run_predriver+0x21> <== NOT EXECUTED (*the_extension->predriver_hook)(); 10ac77: ff d0 call *%eax <== 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 ) { 10ac79: 8b 1b mov (%ebx),%ebx <== 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 ) ; 10ac7b: 81 fb 1c fa 11 00 cmp $0x11fa1c,%ebx <== NOT EXECUTED 10ac81: 75 ed jne 10ac70 <_API_extensions_Run_predriver+0x18> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) (*the_extension->predriver_hook)(); } } 10ac83: 58 pop %eax <== NOT EXECUTED 10ac84: 5b pop %ebx <== NOT EXECUTED 10ac85: c9 leave <== NOT EXECUTED 10ac86: c3 ret <== NOT EXECUTED 0010f290 <_Barrier_Manager_initialization>: */ void _Barrier_Manager_initialization( uint32_t maximum_barriers ) { 10f290: 55 push %ebp <== NOT EXECUTED 10f291: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f293: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f296: 6a 04 push $0x4 <== NOT EXECUTED 10f298: 6a 00 push $0x0 <== NOT EXECUTED 10f29a: 6a 60 push $0x60 <== NOT EXECUTED 10f29c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f29f: 6a 0a push $0xa <== NOT EXECUTED 10f2a1: 6a 02 push $0x2 <== NOT EXECUTED 10f2a3: 68 40 02 12 00 push $0x120240 <== NOT EXECUTED 10f2a8: e8 bf c8 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f2ad: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10f2b0: c9 leave <== NOT EXECUTED 10f2b1: c3 ret <== NOT EXECUTED 001102cc <_Barrier_Translate_core_barrier_return_code>: }; rtems_status_code _Barrier_Translate_core_barrier_return_code ( CORE_barrier_Status the_barrier_status ) { 1102cc: 55 push %ebp <== NOT EXECUTED 1102cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1102cf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1102d2: 8b 04 85 14 05 12 00 mov 0x120514(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_barrier_status > CORE_BARRIER_STATUS_LAST ) return RTEMS_INTERNAL_ERROR; #endif return _Barrier_Translate_core_barrier_return_code_[the_barrier_status]; } 1102d9: c9 leave <== NOT EXECUTED 1102da: c3 ret <== NOT EXECUTED 0010cd98 <_CORE_RWLock_Initialize>: void _CORE_RWLock_Initialize( CORE_RWLock_Control *the_rwlock, CORE_RWLock_Attributes *the_rwlock_attributes ) { 10cd98: 55 push %ebp <== NOT EXECUTED 10cd99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cd9b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cd9e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED the_rwlock->Attributes = *the_rwlock_attributes; 10cda1: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10cda4: 8b 12 mov (%edx),%edx <== NOT EXECUTED 10cda6: 89 50 40 mov %edx,0x40(%eax) <== NOT EXECUTED /* the_rwlock->number_of_waiting_threads = 0; */ the_rwlock->number_of_readers = 0; 10cda9: c7 40 48 00 00 00 00 movl $0x0,0x48(%eax) <== NOT EXECUTED the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 10cdb0: c7 40 44 00 00 00 00 movl $0x0,0x44(%eax) <== NOT EXECUTED _Thread_queue_Initialize( 10cdb7: 6a 03 push $0x3 <== NOT EXECUTED 10cdb9: 68 00 00 02 00 push $0x20000 <== NOT EXECUTED 10cdbe: 6a 00 push $0x0 <== NOT EXECUTED 10cdc0: 50 push %eax <== NOT EXECUTED 10cdc1: e8 4a 1c 00 00 call 10ea10 <_Thread_queue_Initialize> <== NOT EXECUTED 10cdc6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &the_rwlock->Wait_queue, THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_RWLOCK, CORE_RWLOCK_TIMEOUT ); } 10cdc9: c9 leave <== NOT EXECUTED 10cdca: c3 ret <== NOT EXECUTED 0010cdcc <_CORE_RWLock_Obtain_for_reading>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_RWLock_API_mp_support_callout api_rwlock_mp_support ) { 10cdcc: 55 push %ebp <== NOT EXECUTED 10cdcd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cdcf: 57 push %edi <== NOT EXECUTED 10cdd0: 56 push %esi <== NOT EXECUTED 10cdd1: 53 push %ebx <== NOT EXECUTED 10cdd2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cdd5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10cdd8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10cddb: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 10cdde: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10cde1: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 10cde4: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10cde7: 88 45 ef mov %al,-0x11(%ebp) <== NOT EXECUTED ISR_Level level; Thread_Control *executing = _Thread_Executing; 10cdea: 8b 35 dc 20 12 00 mov 0x1220dc,%esi <== NOT EXECUTED * If unlocked, then OK to read. * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); 10cdf0: 9c pushf <== NOT EXECUTED 10cdf1: fa cli <== NOT EXECUTED 10cdf2: 5f pop %edi <== NOT EXECUTED switch ( the_rwlock->current_state ) { 10cdf3: 8b 43 44 mov 0x44(%ebx),%eax <== NOT EXECUTED 10cdf6: 85 c0 test %eax,%eax <== NOT EXECUTED 10cdf8: 75 1e jne 10ce18 <_CORE_RWLock_Obtain_for_reading+0x4c> <== NOT EXECUTED case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10cdfa: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) <== NOT EXECUTED the_rwlock->number_of_readers += 1; 10ce01: ff 43 48 incl 0x48(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10ce04: 57 push %edi <== NOT EXECUTED 10ce05: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10ce06: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) <== NOT EXECUTED timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10ce0d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ce10: 5b pop %ebx <== NOT EXECUTED 10ce11: 5e pop %esi <== NOT EXECUTED 10ce12: 5f pop %edi <== NOT EXECUTED 10ce13: c9 leave <== NOT EXECUTED 10ce14: c3 ret <== NOT EXECUTED 10ce15: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * If locked for reading and no waiters, then OK to read. * If any thread is waiting, then we wait. */ _ISR_Disable( level ); switch ( the_rwlock->current_state ) { 10ce18: 48 dec %eax <== NOT EXECUTED 10ce19: 74 55 je 10ce70 <_CORE_RWLock_Obtain_for_reading+0xa4> <== NOT EXECUTED /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { 10ce1b: 80 7d ef 00 cmpb $0x0,-0x11(%ebp) <== NOT EXECUTED 10ce1f: 75 13 jne 10ce34 <_CORE_RWLock_Obtain_for_reading+0x68> <== NOT EXECUTED _ISR_Enable( level ); 10ce21: 57 push %edi <== NOT EXECUTED 10ce22: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10ce23: c7 46 34 02 00 00 00 movl $0x2,0x34(%esi) <== NOT EXECUTED timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10ce2a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ce2d: 5b pop %ebx <== NOT EXECUTED 10ce2e: 5e pop %esi <== NOT EXECUTED 10ce2f: 5f pop %edi <== NOT EXECUTED 10ce30: c9 leave <== NOT EXECUTED 10ce31: c3 ret <== NOT EXECUTED 10ce32: 66 90 xchg %ax,%ax <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10ce34: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) <== NOT EXECUTED /* * We need to wait to enter this critical section */ _Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue ); executing->Wait.queue = &the_rwlock->Wait_queue; 10ce3b: 89 5e 44 mov %ebx,0x44(%esi) <== NOT EXECUTED executing->Wait.id = id; 10ce3e: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10ce41: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ; 10ce44: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi) <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10ce4b: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) <== NOT EXECUTED _ISR_Enable( level ); 10ce52: 57 push %edi <== NOT EXECUTED 10ce53: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue_with_handler( 10ce54: c7 45 10 c8 cf 10 00 movl $0x10cfc8,0x10(%ebp) <== NOT EXECUTED 10ce5b: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10ce5e: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10ce61: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED timeout, _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10ce64: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ce67: 5b pop %ebx <== NOT EXECUTED 10ce68: 5e pop %esi <== NOT EXECUTED 10ce69: 5f pop %edi <== NOT EXECUTED 10ce6a: c9 leave <== NOT EXECUTED executing->Wait.id = id; executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_READ; executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; _ISR_Enable( level ); _Thread_queue_Enqueue_with_handler( 10ce6b: e9 e0 17 00 00 jmp 10e650 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; return; case CORE_RWLOCK_LOCKED_FOR_READING: { Thread_Control *waiter; waiter = _Thread_queue_First( &the_rwlock->Wait_queue ); 10ce70: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ce73: 53 push %ebx <== NOT EXECUTED 10ce74: e8 13 1b 00 00 call 10e98c <_Thread_queue_First> <== NOT EXECUTED if ( !waiter ) { 10ce79: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ce7c: 85 c0 test %eax,%eax <== NOT EXECUTED 10ce7e: 75 9b jne 10ce1b <_CORE_RWLock_Obtain_for_reading+0x4f> <== NOT EXECUTED the_rwlock->number_of_readers += 1; 10ce80: ff 43 48 incl 0x48(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10ce83: 57 push %edi <== NOT EXECUTED 10ce84: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10ce85: c7 46 34 00 00 00 00 movl $0x0,0x34(%esi) <== NOT EXECUTED 10ce8c: e9 7c ff ff ff jmp 10ce0d <_CORE_RWLock_Obtain_for_reading+0x41> <== NOT EXECUTED 0010ce94 <_CORE_RWLock_Obtain_for_writing>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_RWLock_API_mp_support_callout api_rwlock_mp_support ) { 10ce94: 55 push %ebp <== NOT EXECUTED 10ce95: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ce97: 57 push %edi <== NOT EXECUTED 10ce98: 56 push %esi <== NOT EXECUTED 10ce99: 53 push %ebx <== NOT EXECUTED 10ce9a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ce9d: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10cea0: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 10cea3: 8a 5d 10 mov 0x10(%ebp),%bl <== NOT EXECUTED ISR_Level level; Thread_Control *executing = _Thread_Executing; 10cea6: 8b 15 dc 20 12 00 mov 0x1220dc,%edx <== NOT EXECUTED * 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 ); 10ceac: 9c pushf <== NOT EXECUTED 10cead: fa cli <== NOT EXECUTED 10ceae: 59 pop %ecx <== NOT EXECUTED switch ( the_rwlock->current_state ) { 10ceaf: 83 78 44 00 cmpl $0x0,0x44(%eax) <== NOT EXECUTED 10ceb3: 75 17 jne 10cecc <_CORE_RWLock_Obtain_for_writing+0x38> <== NOT EXECUTED case CORE_RWLOCK_UNLOCKED: the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING; 10ceb5: c7 40 44 02 00 00 00 movl $0x2,0x44(%eax) <== NOT EXECUTED _ISR_Enable( level ); 10cebc: 51 push %ecx <== NOT EXECUTED 10cebd: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10cebe: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10cec5: 5b pop %ebx <== NOT EXECUTED 10cec6: 5e pop %esi <== NOT EXECUTED 10cec7: 5f pop %edi <== NOT EXECUTED 10cec8: c9 leave <== NOT EXECUTED 10cec9: c3 ret <== NOT EXECUTED 10ceca: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * If the thread is not willing to wait, then return immediately. */ if ( !wait ) { 10cecc: 84 db test %bl,%bl <== NOT EXECUTED 10cece: 75 10 jne 10cee0 <_CORE_RWLock_Obtain_for_writing+0x4c> <== NOT EXECUTED _ISR_Enable( level ); 10ced0: 51 push %ecx <== NOT EXECUTED 10ced1: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10ced2: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) <== NOT EXECUTED _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10ced9: 5b pop %ebx <== NOT EXECUTED 10ceda: 5e pop %esi <== NOT EXECUTED 10cedb: 5f pop %edi <== NOT EXECUTED 10cedc: c9 leave <== NOT EXECUTED 10cedd: c3 ret <== NOT EXECUTED 10cede: 66 90 xchg %ax,%ax <== NOT EXECUTED 10cee0: c7 40 30 01 00 00 00 movl $0x1,0x30(%eax) <== NOT EXECUTED /* * We need to wait to enter this critical section */ _Thread_queue_Enter_critical_section( &the_rwlock->Wait_queue ); executing->Wait.queue = &the_rwlock->Wait_queue; 10cee7: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED executing->Wait.id = id; 10ceea: 89 72 20 mov %esi,0x20(%edx) <== NOT EXECUTED executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE; 10ceed: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx) <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10cef4: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED _ISR_Enable( level ); 10cefb: 51 push %ecx <== NOT EXECUTED 10cefc: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue_with_handler( 10cefd: c7 45 10 c8 cf 10 00 movl $0x10cfc8,0x10(%ebp) <== NOT EXECUTED 10cf04: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 10cf07: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED _CORE_RWLock_Timeout ); /* return to API level so it can dispatch and we block */ } 10cf0a: 5b pop %ebx <== NOT EXECUTED 10cf0b: 5e pop %esi <== NOT EXECUTED 10cf0c: 5f pop %edi <== NOT EXECUTED 10cf0d: c9 leave <== NOT EXECUTED executing->Wait.id = id; executing->Wait.option = CORE_RWLOCK_THREAD_WAITING_FOR_WRITE; executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; _ISR_Enable( level ); _Thread_queue_Enqueue_with_handler( 10cf0e: e9 3d 17 00 00 jmp 10e650 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 0010cf14 <_CORE_RWLock_Release>: */ CORE_RWLock_Status _CORE_RWLock_Release( CORE_RWLock_Control *the_rwlock ) { 10cf14: 55 push %ebp <== NOT EXECUTED 10cf15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cf17: 53 push %ebx <== NOT EXECUTED 10cf18: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10cf1b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; Thread_Control *executing = _Thread_Executing; 10cf1e: 8b 0d dc 20 12 00 mov 0x1220dc,%ecx <== NOT EXECUTED * 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 ); 10cf24: 9c pushf <== NOT EXECUTED 10cf25: fa cli <== NOT EXECUTED 10cf26: 5a pop %edx <== NOT EXECUTED if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ 10cf27: 8b 43 44 mov 0x44(%ebx),%eax <== NOT EXECUTED 10cf2a: 85 c0 test %eax,%eax <== NOT EXECUTED 10cf2c: 74 7a je 10cfa8 <_CORE_RWLock_Release+0x94> <== NOT EXECUTED _ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; return CORE_RWLOCK_SUCCESSFUL; } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { 10cf2e: 48 dec %eax <== NOT EXECUTED 10cf2f: 74 63 je 10cf94 <_CORE_RWLock_Release+0x80> <== NOT EXECUTED return CORE_RWLOCK_SUCCESSFUL; } } /* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */ executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL; 10cf31: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) <== NOT EXECUTED /* * Implicitly transition to "unlocked" and find another thread interested * in obtaining this rwlock. */ the_rwlock->current_state = CORE_RWLOCK_UNLOCKED; 10cf38: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10cf3f: 52 push %edx <== NOT EXECUTED 10cf40: 9d popf <== NOT EXECUTED next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue ); 10cf41: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cf44: 53 push %ebx <== NOT EXECUTED 10cf45: e8 ca 15 00 00 call 10e514 <_Thread_queue_Dequeue> <== NOT EXECUTED if ( next ) { 10cf4a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cf4d: 85 c0 test %eax,%eax <== NOT EXECUTED 10cf4f: 74 39 je 10cf8a <_CORE_RWLock_Release+0x76> <== NOT EXECUTED if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) { 10cf51: 83 78 30 01 cmpl $0x1,0x30(%eax) <== NOT EXECUTED 10cf55: 74 61 je 10cfb8 <_CORE_RWLock_Release+0xa4> <== NOT EXECUTED } /* * Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING */ the_rwlock->number_of_readers += 1; 10cf57: ff 43 48 incl 0x48(%ebx) <== NOT EXECUTED the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING; 10cf5a: c7 43 44 01 00 00 00 movl $0x1,0x44(%ebx) <== NOT EXECUTED 10cf61: eb 17 jmp 10cf7a <_CORE_RWLock_Release+0x66> <== NOT EXECUTED 10cf63: 90 nop <== NOT EXECUTED /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); if ( !next || 10cf64: 83 78 30 01 cmpl $0x1,0x30(%eax) <== NOT EXECUTED 10cf68: 74 20 je 10cf8a <_CORE_RWLock_Release+0x76> <== NOT EXECUTED next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) return CORE_RWLOCK_SUCCESSFUL; the_rwlock->number_of_readers += 1; 10cf6a: ff 43 48 incl 0x48(%ebx) <== NOT EXECUTED _Thread_queue_Extract( &the_rwlock->Wait_queue, next ); 10cf6d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cf70: 50 push %eax <== NOT EXECUTED 10cf71: 53 push %ebx <== NOT EXECUTED 10cf72: e8 f5 18 00 00 call 10e86c <_Thread_queue_Extract> <== NOT EXECUTED 10cf77: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Now see if more readers can be let go. */ while ( 1 ) { next = _Thread_queue_First( &the_rwlock->Wait_queue ); 10cf7a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cf7d: 53 push %ebx <== NOT EXECUTED 10cf7e: e8 09 1a 00 00 call 10e98c <_Thread_queue_First> <== NOT EXECUTED if ( !next || 10cf83: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cf86: 85 c0 test %eax,%eax <== NOT EXECUTED 10cf88: 75 da jne 10cf64 <_CORE_RWLock_Release+0x50> <== NOT EXECUTED } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10cf8a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cf8c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cf8f: c9 leave <== NOT EXECUTED 10cf90: c3 ret <== NOT EXECUTED 10cf91: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _ISR_Enable( level ); executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; return CORE_RWLOCK_SUCCESSFUL; } if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) { the_rwlock->number_of_readers -= 1; 10cf94: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10cf97: 48 dec %eax <== NOT EXECUTED 10cf98: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED if ( the_rwlock->number_of_readers != 0 ) { 10cf9b: 85 c0 test %eax,%eax <== NOT EXECUTED 10cf9d: 74 92 je 10cf31 <_CORE_RWLock_Release+0x1d> <== NOT EXECUTED /* must be unlocked again */ _ISR_Enable( level ); 10cf9f: 52 push %edx <== NOT EXECUTED 10cfa0: 9d popf <== NOT EXECUTED } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10cfa1: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cfa3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cfa6: c9 leave <== NOT EXECUTED 10cfa7: c3 ret <== NOT EXECUTED * If any thread is waiting, then we wait. */ _ISR_Disable( level ); if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){ _ISR_Enable( level ); 10cfa8: 52 push %edx <== NOT EXECUTED 10cfa9: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE; 10cfaa: c7 41 34 02 00 00 00 movl $0x2,0x34(%ecx) <== NOT EXECUTED } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10cfb1: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cfb3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cfb6: c9 leave <== NOT EXECUTED 10cfb7: c3 ret <== NOT EXECUTED 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; 10cfb8: c7 43 44 02 00 00 00 movl $0x2,0x44(%ebx) <== NOT EXECUTED } /* indentation is to match _ISR_Disable at top */ return CORE_RWLOCK_SUCCESSFUL; } 10cfbf: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cfc1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cfc4: c9 leave <== NOT EXECUTED 10cfc5: c3 ret <== NOT EXECUTED 0010cfc8 <_CORE_RWLock_Timeout>: void _CORE_RWLock_Timeout( Objects_Id id, void *ignored ) { 10cfc8: 55 push %ebp <== NOT EXECUTED 10cfc9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cfcb: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10cfce: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10cfd1: 50 push %eax <== NOT EXECUTED 10cfd2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cfd5: e8 da 11 00 00 call 10e1b4 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10cfda: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cfdd: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10cfe0: 85 d2 test %edx,%edx <== NOT EXECUTED 10cfe2: 75 17 jne 10cffb <_CORE_RWLock_Timeout+0x33> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10cfe4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cfe7: 50 push %eax <== NOT EXECUTED 10cfe8: e8 a3 1a 00 00 call 10ea90 <_Thread_queue_Process_timeout> <== NOT EXECUTED 10cfed: a1 18 20 12 00 mov 0x122018,%eax <== NOT EXECUTED 10cff2: 48 dec %eax <== NOT EXECUTED 10cff3: a3 18 20 12 00 mov %eax,0x122018 <== NOT EXECUTED 10cff8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Unnest_dispatch(); break; } } 10cffb: c9 leave <== NOT EXECUTED 10cffc: c3 ret <== NOT EXECUTED 0010bf30 <_CORE_barrier_Initialize>: void _CORE_barrier_Initialize( CORE_barrier_Control *the_barrier, CORE_barrier_Attributes *the_barrier_attributes ) { 10bf30: 55 push %ebp <== NOT EXECUTED 10bf31: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf33: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bf36: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bf39: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED the_barrier->Attributes = *the_barrier_attributes; 10bf3c: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10bf3e: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10bf41: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED 10bf44: 89 4a 40 mov %ecx,0x40(%edx) <== NOT EXECUTED the_barrier->number_of_waiting_threads = 0; 10bf47: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) <== NOT EXECUTED _Thread_queue_Initialize( 10bf4e: 6a 03 push $0x3 <== NOT EXECUTED 10bf50: 68 00 00 01 00 push $0x10000 <== NOT EXECUTED 10bf55: 6a 00 push $0x0 <== NOT EXECUTED 10bf57: 52 push %edx <== NOT EXECUTED 10bf58: e8 e3 1c 00 00 call 10dc40 <_Thread_queue_Initialize> <== NOT EXECUTED 10bf5d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &the_barrier->Wait_queue, THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_BARRIER, CORE_BARRIER_TIMEOUT ); } 10bf60: c9 leave <== NOT EXECUTED 10bf61: c3 ret <== NOT EXECUTED 00110934 <_CORE_barrier_Release>: uint32_t _CORE_barrier_Release( CORE_barrier_Control *the_barrier, Objects_Id id, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 110934: 55 push %ebp <== NOT EXECUTED 110935: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110937: 56 push %esi <== NOT EXECUTED 110938: 53 push %ebx <== NOT EXECUTED 110939: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Thread_Control *the_thread; uint32_t count; count = 0; while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) { 11093c: 31 db xor %ebx,%ebx <== NOT EXECUTED 11093e: eb 01 jmp 110941 <_CORE_barrier_Release+0xd> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_barrier_mp_support) ( the_thread, id ); #endif count++; 110940: 43 inc %ebx <== NOT EXECUTED { Thread_Control *the_thread; uint32_t count; count = 0; while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) { 110941: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110944: 56 push %esi <== NOT EXECUTED 110945: e8 46 cf ff ff call 10d890 <_Thread_queue_Dequeue> <== NOT EXECUTED 11094a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11094d: 85 c0 test %eax,%eax <== NOT EXECUTED 11094f: 75 ef jne 110940 <_CORE_barrier_Release+0xc> <== NOT EXECUTED if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_barrier_mp_support) ( the_thread, id ); #endif count++; } the_barrier->number_of_waiting_threads = 0; 110951: c7 46 48 00 00 00 00 movl $0x0,0x48(%esi) <== NOT EXECUTED return count; } 110958: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11095a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11095d: 5b pop %ebx <== NOT EXECUTED 11095e: 5e pop %esi <== NOT EXECUTED 11095f: c9 leave <== NOT EXECUTED 110960: c3 ret <== NOT EXECUTED 0010bf64 <_CORE_barrier_Wait>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 10bf64: 55 push %ebp <== NOT EXECUTED 10bf65: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf67: 57 push %edi <== NOT EXECUTED 10bf68: 56 push %esi <== NOT EXECUTED 10bf69: 53 push %ebx <== NOT EXECUTED 10bf6a: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bf6d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bf70: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10bf73: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 10bf76: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10bf79: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 10bf7c: 8b 0d dc 0f 12 00 mov 0x120fdc,%ecx <== NOT EXECUTED executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; 10bf82: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) <== NOT EXECUTED _ISR_Disable( level ); 10bf89: 9c pushf <== NOT EXECUTED 10bf8a: fa cli <== NOT EXECUTED 10bf8b: 5b pop %ebx <== NOT EXECUTED the_barrier->number_of_waiting_threads++; 10bf8c: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED 10bf8f: 40 inc %eax <== NOT EXECUTED 10bf90: 89 42 48 mov %eax,0x48(%edx) <== NOT EXECUTED if ( the_barrier->number_of_waiting_threads == 10bf93: 3b 42 44 cmp 0x44(%edx),%eax <== NOT EXECUTED 10bf96: 75 07 jne 10bf9f <_CORE_barrier_Wait+0x3b> <== NOT EXECUTED the_barrier->Attributes.maximum_count) { if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { 10bf98: 8b 42 40 mov 0x40(%edx),%eax <== NOT EXECUTED 10bf9b: 85 c0 test %eax,%eax <== NOT EXECUTED 10bf9d: 74 29 je 10bfc8 <_CORE_barrier_Wait+0x64> <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10bf9f: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx) <== NOT EXECUTED return; } } _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue ); executing->Wait.queue = &the_barrier->Wait_queue; 10bfa6: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED executing->Wait.id = id; 10bfa9: 89 79 20 mov %edi,0x20(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10bfac: 53 push %ebx <== NOT EXECUTED 10bfad: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 10bfae: c7 45 10 1c dd 10 00 movl $0x10dd1c,0x10(%ebp) <== NOT EXECUTED 10bfb5: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10bfb8: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10bfbb: 58 pop %eax <== NOT EXECUTED 10bfbc: 5b pop %ebx <== NOT EXECUTED 10bfbd: 5e pop %esi <== NOT EXECUTED 10bfbe: 5f pop %edi <== NOT EXECUTED 10bfbf: c9 leave <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue ); executing->Wait.queue = &the_barrier->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 10bfc0: e9 07 1a 00 00 jmp 10d9cc <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 10bfc5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _ISR_Disable( level ); the_barrier->number_of_waiting_threads++; if ( the_barrier->number_of_waiting_threads == the_barrier->Attributes.maximum_count) { if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED; 10bfc8: c7 41 34 01 00 00 00 movl $0x1,0x34(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10bfcf: 53 push %ebx <== NOT EXECUTED 10bfd0: 9d popf <== NOT EXECUTED _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support ); 10bfd1: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10bfd4: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 10bfd7: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 10bfda: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED executing->Wait.queue = &the_barrier->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); } 10bfdd: 5a pop %edx <== NOT EXECUTED 10bfde: 5b pop %ebx <== NOT EXECUTED 10bfdf: 5e pop %esi <== NOT EXECUTED 10bfe0: 5f pop %edi <== NOT EXECUTED 10bfe1: c9 leave <== NOT EXECUTED if ( the_barrier->number_of_waiting_threads == the_barrier->Attributes.maximum_count) { if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED; _ISR_Enable( level ); _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support ); 10bfe2: e9 4d 49 00 00 jmp 110934 <_CORE_barrier_Release> <== NOT EXECUTED 0011559c <_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 ) { 11559c: 55 push %ebp <== NOT EXECUTED 11559d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11559f: 57 push %edi <== NOT EXECUTED 1155a0: 56 push %esi <== NOT EXECUTED 1155a1: 53 push %ebx <== NOT EXECUTED 1155a2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 1155a5: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 1155a8: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1155ab: 39 50 4c cmp %edx,0x4c(%eax) <== NOT EXECUTED 1155ae: 72 58 jb 115608 <_CORE_message_queue_Broadcast+0x6c> <== NOT EXECUTED * 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 ) { 1155b0: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 1155b3: 8b 46 48 mov 0x48(%esi),%eax <== NOT EXECUTED 1155b6: 85 c0 test %eax,%eax <== NOT EXECUTED 1155b8: 75 3a jne 1155f4 <_CORE_message_queue_Broadcast+0x58> <== NOT EXECUTED * 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))) { 1155ba: 31 db xor %ebx,%ebx <== NOT EXECUTED 1155bc: eb 16 jmp 1155d4 <_CORE_message_queue_Broadcast+0x38> <== NOT EXECUTED 1155be: 66 90 xchg %ax,%ax <== NOT EXECUTED waitp = &the_thread->Wait; number_broadcasted += 1; 1155c0: 43 inc %ebx <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 1155c1: 8b 78 2c mov 0x2c(%eax),%edi <== NOT EXECUTED 1155c4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1155c7: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 1155ca: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 1155cc: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 1155cf: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 1155d2: 89 10 mov %edx,(%eax) <== NOT EXECUTED * 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))) { 1155d4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1155d7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1155da: e8 29 22 00 00 call 117808 <_Thread_queue_Dequeue> <== NOT EXECUTED 1155df: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1155e2: 85 c0 test %eax,%eax <== NOT EXECUTED 1155e4: 75 da jne 1155c0 <_CORE_message_queue_Broadcast+0x24> <== NOT EXECUTED if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif } *count = number_broadcasted; 1155e6: 8b 75 1c mov 0x1c(%ebp),%esi <== NOT EXECUTED 1155e9: 89 1e mov %ebx,(%esi) <== NOT EXECUTED return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 1155eb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1155ee: 5b pop %ebx <== NOT EXECUTED 1155ef: 5e pop %esi <== NOT EXECUTED 1155f0: 5f pop %edi <== NOT EXECUTED 1155f1: c9 leave <== NOT EXECUTED 1155f2: c3 ret <== NOT EXECUTED 1155f3: 90 nop <== NOT EXECUTED * 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 ) { *count = 0; 1155f4: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 1155f7: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 1155fd: 31 c0 xor %eax,%eax <== NOT EXECUTED #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 1155ff: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 115602: 5b pop %ebx <== NOT EXECUTED 115603: 5e pop %esi <== NOT EXECUTED 115604: 5f pop %edi <== NOT EXECUTED 115605: c9 leave <== NOT EXECUTED 115606: c3 ret <== NOT EXECUTED 115607: 90 nop <== NOT EXECUTED { Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 115608: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 11560d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 115610: 5b pop %ebx <== NOT EXECUTED 115611: 5e pop %esi <== NOT EXECUTED 115612: 5f pop %edi <== NOT EXECUTED 115613: c9 leave <== NOT EXECUTED 115614: c3 ret <== NOT EXECUTED 001164c8 <_CORE_message_queue_Close>: void _CORE_message_queue_Close( CORE_message_queue_Control *the_message_queue, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 1164c8: 55 push %ebp <== NOT EXECUTED 1164c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1164cb: 53 push %ebx <== NOT EXECUTED 1164cc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1164cf: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* * This will flush blocked threads whether they were blocked on * a send or receive. */ _Thread_queue_Flush( 1164d2: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1164d5: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1164d8: 53 push %ebx <== NOT EXECUTED 1164d9: e8 ae b3 ff ff call 11188c <_Thread_queue_Flush> <== NOT EXECUTED * This removes all messages from the pending message queue. Since * we just flushed all waiting threads, we don't have to worry about * the flush satisfying any blocked senders as a side-effect. */ if ( the_message_queue->number_of_pending_messages != 0 ) 1164de: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1164e1: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 1164e4: 85 c0 test %eax,%eax <== NOT EXECUTED 1164e6: 74 0c je 1164f4 <_CORE_message_queue_Close+0x2c> <== NOT EXECUTED (void) _CORE_message_queue_Flush_support( the_message_queue ); 1164e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1164eb: 53 push %ebx <== NOT EXECUTED 1164ec: e8 13 00 00 00 call 116504 <_CORE_message_queue_Flush_support> <== NOT EXECUTED 1164f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (void) _Workspace_Free( the_message_queue->message_buffers ); 1164f4: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED 1164f7: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 1164fa: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1164fd: c9 leave <== NOT EXECUTED */ if ( the_message_queue->number_of_pending_messages != 0 ) (void) _CORE_message_queue_Flush_support( the_message_queue ); (void) _Workspace_Free( the_message_queue->message_buffers ); 1164fe: e9 2d be ff ff jmp 112330 <_Workspace_Free> <== NOT EXECUTED 00115654 <_CORE_message_queue_Flush>: */ uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue ) { 115654: 55 push %ebp <== NOT EXECUTED 115655: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115657: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages != 0 ) 11565a: 8b 50 48 mov 0x48(%eax),%edx <== NOT EXECUTED 11565d: 85 d2 test %edx,%edx <== NOT EXECUTED 11565f: 75 07 jne 115668 <_CORE_message_queue_Flush+0x14> <== NOT EXECUTED return _CORE_message_queue_Flush_support( the_message_queue ); else return 0; } 115661: 31 c0 xor %eax,%eax <== NOT EXECUTED 115663: c9 leave <== NOT EXECUTED 115664: c3 ret <== NOT EXECUTED 115665: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue ) { if ( the_message_queue->number_of_pending_messages != 0 ) return _CORE_message_queue_Flush_support( the_message_queue ); 115668: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED else return 0; } 11566b: c9 leave <== NOT EXECUTED uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue ) { if ( the_message_queue->number_of_pending_messages != 0 ) return _CORE_message_queue_Flush_support( the_message_queue ); 11566c: e9 03 00 00 00 jmp 115674 <_CORE_message_queue_Flush_support> <== NOT EXECUTED 00116504 <_CORE_message_queue_Flush_support>: */ uint32_t _CORE_message_queue_Flush_support( CORE_message_queue_Control *the_message_queue ) { 116504: 55 push %ebp <== NOT EXECUTED 116505: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116507: 56 push %esi <== NOT EXECUTED 116508: 53 push %ebx <== NOT EXECUTED 116509: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED * * For now, though, we are very happy to have a small routine with * fixed execution time that only deals with pending messages. */ _ISR_Disable( level ); 11650c: 9c pushf <== NOT EXECUTED 11650d: fa cli <== NOT EXECUTED 11650e: 5e pop %esi <== NOT EXECUTED inactive_first = the_message_queue->Inactive_messages.first; 11650f: 8b 4a 68 mov 0x68(%edx),%ecx <== NOT EXECUTED message_queue_first = the_message_queue->Pending_messages.first; 116512: 8b 5a 50 mov 0x50(%edx),%ebx <== NOT EXECUTED message_queue_last = the_message_queue->Pending_messages.last; 116515: 8b 42 58 mov 0x58(%edx),%eax <== NOT EXECUTED the_message_queue->Inactive_messages.first = message_queue_first; 116518: 89 5a 68 mov %ebx,0x68(%edx) <== NOT EXECUTED message_queue_last->next = inactive_first; 11651b: 89 08 mov %ecx,(%eax) <== NOT EXECUTED inactive_first->previous = message_queue_last; 11651d: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED message_queue_first->previous = 116520: 8d 42 68 lea 0x68(%edx),%eax <== NOT EXECUTED 116523: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED 116526: 8d 42 54 lea 0x54(%edx),%eax <== NOT EXECUTED 116529: 89 42 50 mov %eax,0x50(%edx) <== NOT EXECUTED 11652c: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) <== NOT EXECUTED 116533: 8d 42 50 lea 0x50(%edx),%eax <== NOT EXECUTED 116536: 89 42 58 mov %eax,0x58(%edx) <== NOT EXECUTED _Chain_Head( &the_message_queue->Inactive_messages ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); count = the_message_queue->number_of_pending_messages; 116539: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED the_message_queue->number_of_pending_messages = 0; 11653c: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) <== NOT EXECUTED _ISR_Enable( level ); 116543: 56 push %esi <== NOT EXECUTED 116544: 9d popf <== NOT EXECUTED return count; } 116545: 5b pop %ebx <== NOT EXECUTED 116546: 5e pop %esi <== NOT EXECUTED 116547: c9 leave <== NOT EXECUTED 116548: c3 ret <== NOT EXECUTED 0010fe64 <_CORE_message_queue_Initialize>: CORE_message_queue_Control *the_message_queue, CORE_message_queue_Attributes *the_message_queue_attributes, uint32_t maximum_pending_messages, size_t maximum_message_size ) { 10fe64: 55 push %ebp <== NOT EXECUTED 10fe65: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fe67: 57 push %edi <== NOT EXECUTED 10fe68: 56 push %esi <== NOT EXECUTED 10fe69: 53 push %ebx <== NOT EXECUTED 10fe6a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fe6d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10fe70: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10fe73: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED size_t message_buffering_required; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; 10fe76: 89 7b 44 mov %edi,0x44(%ebx) <== NOT EXECUTED the_message_queue->number_of_pending_messages = 0; 10fe79: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) <== NOT EXECUTED the_message_queue->maximum_message_size = maximum_message_size; 10fe80: 89 53 4c mov %edx,0x4c(%ebx) <== NOT EXECUTED 10fe83: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED 10fe8a: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) <== NOT EXECUTED * 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)) { 10fe91: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10fe94: 75 1a jne 10feb0 <_CORE_message_queue_Initialize+0x4c> <== NOT EXECUTED 10fe96: 89 d0 mov %edx,%eax <== NOT EXECUTED /* * Calculate how much total memory is required for message buffering and * check for overflow on the multiplication. */ message_buffering_required = (size_t) maximum_pending_messages * 10fe98: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 10fe9b: 89 f2 mov %esi,%edx <== NOT EXECUTED 10fe9d: 0f af d7 imul %edi,%edx <== NOT EXECUTED (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 10fea0: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10fea2: 73 18 jae 10febc <_CORE_message_queue_Initialize+0x58> <== NOT EXECUTED THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 10fea4: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10fea6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fea9: 5b pop %ebx <== NOT EXECUTED 10feaa: 5e pop %esi <== NOT EXECUTED 10feab: 5f pop %edi <== NOT EXECUTED 10feac: c9 leave <== NOT EXECUTED 10fead: c3 ret <== NOT EXECUTED 10feae: 66 90 xchg %ax,%ax <== NOT EXECUTED * check for overflow on adding overhead to each message. */ allocated_message_size = maximum_message_size; if (allocated_message_size & (sizeof(uint32_t) - 1)) { allocated_message_size += sizeof(uint32_t); 10feb0: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED allocated_message_size &= ~(sizeof(uint32_t) - 1); 10feb3: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED } if (allocated_message_size < maximum_message_size) 10feb6: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10feb8: 77 ea ja 10fea4 <_CORE_message_queue_Initialize+0x40> <== NOT EXECUTED 10feba: eb dc jmp 10fe98 <_CORE_message_queue_Initialize+0x34> <== NOT EXECUTED return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 10febc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10febf: 52 push %edx <== NOT EXECUTED 10fec0: e8 e7 29 00 00 call 1128ac <_Workspace_Allocate> <== NOT EXECUTED 10fec5: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 10fec8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fecb: 85 c0 test %eax,%eax <== NOT EXECUTED 10fecd: 74 d5 je 10fea4 <_CORE_message_queue_Initialize+0x40> <== NOT EXECUTED /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 10fecf: 56 push %esi <== NOT EXECUTED 10fed0: 57 push %edi <== NOT EXECUTED 10fed1: 50 push %eax <== NOT EXECUTED 10fed2: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 10fed5: 50 push %eax <== NOT EXECUTED 10fed6: e8 8d 6c 01 00 call 126b68 <_Chain_Initialize> <== NOT EXECUTED 10fedb: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10fede: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED 10fee1: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED 10fee8: 8d 43 50 lea 0x50(%ebx),%eax <== NOT EXECUTED 10feeb: 89 43 58 mov %eax,0x58(%ebx) <== NOT EXECUTED allocated_message_size + sizeof( CORE_message_queue_Buffer_control ) ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); _Thread_queue_Initialize( 10feee: 6a 06 push $0x6 <== NOT EXECUTED 10fef0: 68 80 00 00 00 push $0x80 <== NOT EXECUTED 10fef5: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10fef8: 83 38 01 cmpl $0x1,(%eax) <== NOT EXECUTED 10fefb: 0f 94 c0 sete %al <== NOT EXECUTED 10fefe: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10ff01: 50 push %eax <== NOT EXECUTED 10ff02: 53 push %ebx <== NOT EXECUTED 10ff03: e8 a4 1f 00 00 call 111eac <_Thread_queue_Initialize> <== NOT EXECUTED 10ff08: b0 01 mov $0x1,%al <== NOT EXECUTED 10ff0a: 83 c4 20 add $0x20,%esp <== NOT EXECUTED STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; } 10ff0d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ff10: 5b pop %ebx <== NOT EXECUTED 10ff11: 5e pop %esi <== NOT EXECUTED 10ff12: 5f pop %edi <== NOT EXECUTED 10ff13: c9 leave <== NOT EXECUTED 10ff14: c3 ret <== NOT EXECUTED 0010f71c <_CORE_message_queue_Insert_message>: void _CORE_message_queue_Insert_message( CORE_message_queue_Control *the_message_queue, CORE_message_queue_Buffer_control *the_message, CORE_message_queue_Submit_types submit_type ) { 10f71c: 55 push %ebp <== NOT EXECUTED 10f71d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f71f: 57 push %edi <== NOT EXECUTED 10f720: 56 push %esi <== NOT EXECUTED 10f721: 53 push %ebx <== NOT EXECUTED 10f722: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10f725: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10f728: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10f72b: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED ISR_Level level; bool notify = false; the_message->priority = submit_type; 10f72e: 89 47 08 mov %eax,0x8(%edi) <== NOT EXECUTED switch ( submit_type ) { 10f731: 3d 00 00 00 80 cmp $0x80000000,%eax <== NOT EXECUTED 10f736: 0f 84 94 00 00 00 je 10f7d0 <_CORE_message_queue_Insert_message+0xb4> <== NOT EXECUTED 10f73c: 3d ff ff ff 7f cmp $0x7fffffff,%eax <== NOT EXECUTED 10f741: 74 65 je 10f7a8 <_CORE_message_queue_Insert_message+0x8c> <== NOT EXECUTED CORE_message_queue_Buffer_control *this_message; Chain_Node *the_node; Chain_Control *the_header; the_header = &the_message_queue->Pending_messages; the_node = the_header->first; 10f743: 8b 5e 50 mov 0x50(%esi),%ebx <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10f746: 8d 56 54 lea 0x54(%esi),%edx <== NOT EXECUTED while ( !_Chain_Is_tail( the_header, the_node ) ) { 10f749: 39 da cmp %ebx,%edx <== NOT EXECUTED 10f74b: 75 49 jne 10f796 <_CORE_message_queue_Insert_message+0x7a> <== NOT EXECUTED 10f74d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10f750: 89 d3 mov %edx,%ebx <== NOT EXECUTED continue; } break; } _ISR_Disable( level ); 10f752: 9c pushf <== NOT EXECUTED 10f753: fa cli <== NOT EXECUTED 10f754: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10f755: 8b 56 48 mov 0x48(%esi),%edx <== NOT EXECUTED 10f758: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10f75b: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 10f75e: 85 d2 test %edx,%edx <== NOT EXECUTED 10f760: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED notify = true; _Chain_Insert_unprotected( the_node->previous, &the_message->Node ); 10f764: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10f767: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED 10f76a: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10f76c: 89 38 mov %edi,(%eax) <== NOT EXECUTED 10f76e: 89 17 mov %edx,(%edi) <== NOT EXECUTED 10f770: 89 7a 04 mov %edi,0x4(%edx) <== NOT EXECUTED _ISR_Enable( level ); 10f773: 51 push %ecx <== NOT EXECUTED 10f774: 9d popf <== NOT EXECUTED * According to POSIX, does this happen before or after the message * is actually enqueued. It is logical to think afterwards, because * the message is actually in the queue at this point. */ if ( notify && the_message_queue->notify_handler ) 10f775: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10f779: 74 25 je 10f7a0 <_CORE_message_queue_Insert_message+0x84> <== NOT EXECUTED 10f77b: 8b 4e 60 mov 0x60(%esi),%ecx <== NOT EXECUTED 10f77e: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f780: 74 1e je 10f7a0 <_CORE_message_queue_Insert_message+0x84> <== NOT EXECUTED (*the_message_queue->notify_handler)( the_message_queue->notify_argument ); 10f782: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED 10f785: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10f788: 5a pop %edx <== NOT EXECUTED 10f789: 5b pop %ebx <== NOT EXECUTED 10f78a: 5e pop %esi <== NOT EXECUTED 10f78b: 5f pop %edi <== NOT EXECUTED 10f78c: c9 leave <== NOT EXECUTED * is actually enqueued. It is logical to think afterwards, because * the message is actually in the queue at this point. */ if ( notify && the_message_queue->notify_handler ) (*the_message_queue->notify_handler)( the_message_queue->notify_argument ); 10f78d: ff e1 jmp *%ecx <== NOT EXECUTED 10f78f: 90 nop <== NOT EXECUTED while ( !_Chain_Is_tail( the_header, the_node ) ) { this_message = (CORE_message_queue_Buffer_control *) the_node; if ( this_message->priority <= the_message->priority ) { the_node = the_node->next; 10f790: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED Chain_Node *the_node; Chain_Control *the_header; the_header = &the_message_queue->Pending_messages; the_node = the_header->first; while ( !_Chain_Is_tail( the_header, the_node ) ) { 10f792: 39 da cmp %ebx,%edx <== NOT EXECUTED 10f794: 74 ba je 10f750 <_CORE_message_queue_Insert_message+0x34> <== NOT EXECUTED this_message = (CORE_message_queue_Buffer_control *) the_node; if ( this_message->priority <= the_message->priority ) { 10f796: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10f799: 7d f5 jge 10f790 <_CORE_message_queue_Insert_message+0x74> <== NOT EXECUTED 10f79b: eb b5 jmp 10f752 <_CORE_message_queue_Insert_message+0x36> <== NOT EXECUTED 10f79d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * the message is actually in the queue at this point. */ if ( notify && the_message_queue->notify_handler ) (*the_message_queue->notify_handler)( the_message_queue->notify_argument ); } 10f7a0: 58 pop %eax <== NOT EXECUTED 10f7a1: 5b pop %ebx <== NOT EXECUTED 10f7a2: 5e pop %esi <== NOT EXECUTED 10f7a3: 5f pop %edi <== NOT EXECUTED 10f7a4: c9 leave <== NOT EXECUTED 10f7a5: c3 ret <== NOT EXECUTED 10f7a6: 66 90 xchg %ax,%ax <== NOT EXECUTED the_message->priority = submit_type; switch ( submit_type ) { case CORE_MESSAGE_QUEUE_SEND_REQUEST: _ISR_Disable( level ); 10f7a8: 9c pushf <== NOT EXECUTED 10f7a9: fa cli <== NOT EXECUTED 10f7aa: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10f7ab: 8b 56 48 mov 0x48(%esi),%edx <== NOT EXECUTED 10f7ae: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10f7b1: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 10f7b4: 85 d2 test %edx,%edx <== NOT EXECUTED 10f7b6: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED 10f7ba: 8d 46 54 lea 0x54(%esi),%eax <== NOT EXECUTED 10f7bd: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10f7bf: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED 10f7c2: 89 7e 58 mov %edi,0x58(%esi) <== NOT EXECUTED 10f7c5: 89 38 mov %edi,(%eax) <== NOT EXECUTED 10f7c7: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED notify = true; _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 10f7ca: 51 push %ecx <== NOT EXECUTED 10f7cb: 9d popf <== NOT EXECUTED 10f7cc: eb a7 jmp 10f775 <_CORE_message_queue_Insert_message+0x59> <== NOT EXECUTED 10f7ce: 66 90 xchg %ax,%ax <== NOT EXECUTED break; case CORE_MESSAGE_QUEUE_URGENT_REQUEST: _ISR_Disable( level ); 10f7d0: 9c pushf <== NOT EXECUTED 10f7d1: fa cli <== NOT EXECUTED 10f7d2: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10f7d3: 8b 56 48 mov 0x48(%esi),%edx <== NOT EXECUTED 10f7d6: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10f7d9: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 10f7dc: 85 d2 test %edx,%edx <== NOT EXECUTED 10f7de: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED size_t size ); /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the 10f7e2: 8d 46 50 lea 0x50(%esi),%eax <== NOT EXECUTED 10f7e5: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED 10f7e8: 8b 46 50 mov 0x50(%esi),%eax <== NOT EXECUTED 10f7eb: 89 7e 50 mov %edi,0x50(%esi) <== NOT EXECUTED 10f7ee: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10f7f0: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED notify = true; _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 10f7f3: 51 push %ecx <== NOT EXECUTED 10f7f4: 9d popf <== NOT EXECUTED 10f7f5: e9 7b ff ff ff jmp 10f775 <_CORE_message_queue_Insert_message+0x59> <== NOT EXECUTED 0011662c <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 11662c: 55 push %ebp <== NOT EXECUTED 11662d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11662f: 57 push %edi <== NOT EXECUTED 116630: 56 push %esi <== NOT EXECUTED 116631: 53 push %ebx <== NOT EXECUTED 116632: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 116635: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 116638: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 11663b: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 11663e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 116641: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 116644: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 116647: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 11664a: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED 11664d: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 116650: 88 45 eb mov %al,-0x15(%ebp) <== NOT EXECUTED ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; Thread_Control *the_thread; executing = _Thread_Executing; 116653: 8b 15 7c dd 12 00 mov 0x12dd7c,%edx <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 116659: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED _ISR_Disable( level ); 116660: 9c pushf <== NOT EXECUTED 116661: fa cli <== NOT EXECUTED 116662: 5e pop %esi <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 116663: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 116666: 8b 58 50 mov 0x50(%eax),%ebx <== NOT EXECUTED 116669: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 11666c: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 11666e: 74 7c je 1166ec <_CORE_message_queue_Seize+0xc0> <== NOT EXECUTED 116670: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 116672: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 116675: 89 57 50 mov %edx,0x50(%edi) <== NOT EXECUTED 116678: 89 f8 mov %edi,%eax <== NOT EXECUTED 11667a: 83 c0 50 add $0x50,%eax <== NOT EXECUTED 11667d: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); if ( the_message != NULL ) { the_message_queue->number_of_pending_messages -= 1; 116680: ff 4f 48 decl 0x48(%edi) <== NOT EXECUTED _ISR_Enable( level ); 116683: 56 push %esi <== NOT EXECUTED 116684: 9d popf <== NOT EXECUTED *size_p = the_message->Contents.size; 116685: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 116688: 89 01 mov %eax,(%ecx) <== NOT EXECUTED _Thread_Executing->Wait.count = the_message->priority; 11668a: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 11668d: a1 7c dd 12 00 mov 0x12dd7c,%eax <== NOT EXECUTED 116692: 89 50 24 mov %edx,0x24(%eax) <== NOT EXECUTED _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p); 116695: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 116698: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 11669b: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED 11669d: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 1166a0: 89 c6 mov %eax,%esi <== NOT EXECUTED 1166a2: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED * * NOTE: If we note that the queue was not full before this receive, * then we can avoid this dequeue. */ the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue ); 1166a4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1166a7: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 1166aa: e8 59 ae ff ff call 111508 <_Thread_queue_Dequeue> <== NOT EXECUTED 1166af: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !the_thread ) { 1166b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1166b4: 85 c0 test %eax,%eax <== NOT EXECUTED 1166b6: 0f 84 84 00 00 00 je 116740 <_CORE_message_queue_Seize+0x114> <== NOT EXECUTED * There was a thread waiting to send a message. This code * puts the messages in the message queue on behalf of the * waiting task. */ the_message->priority = the_thread->Wait.count; 1166bc: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED 1166bf: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED the_message->Contents.size = (size_t) the_thread->Wait.option; 1166c2: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED 1166c5: 89 4b 0c mov %ecx,0xc(%ebx) <== NOT EXECUTED 1166c8: 8b 72 2c mov 0x2c(%edx),%esi <== NOT EXECUTED 1166cb: 8b 7d d8 mov -0x28(%ebp),%edi <== NOT EXECUTED 1166ce: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 1166d0: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 1166d3: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 1166d6: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 1166d9: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1166dc: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 1166df: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1166e2: 5b pop %ebx <== NOT EXECUTED 1166e3: 5e pop %esi <== NOT EXECUTED 1166e4: 5f pop %edi <== NOT EXECUTED 1166e5: c9 leave <== NOT EXECUTED the_thread->Wait.return_argument_second.immutable_object, the_message->Contents.buffer, the_message->Contents.size ); _CORE_message_queue_Insert_message( 1166e6: e9 61 fe ff ff jmp 11654c <_CORE_message_queue_Insert_message> <== NOT EXECUTED 1166eb: 90 nop <== NOT EXECUTED the_message->priority ); return; } if ( !wait ) { 1166ec: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) <== NOT EXECUTED 1166f0: 75 12 jne 116704 <_CORE_message_queue_Seize+0xd8> <== NOT EXECUTED _ISR_Enable( level ); 1166f2: 56 push %esi <== NOT EXECUTED 1166f3: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 1166f4: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx) <== NOT EXECUTED executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } 1166fb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1166fe: 5b pop %ebx <== NOT EXECUTED 1166ff: 5e pop %esi <== NOT EXECUTED 116700: 5f pop %edi <== NOT EXECUTED 116701: c9 leave <== NOT EXECUTED 116702: c3 ret <== NOT EXECUTED 116703: 90 nop <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 116704: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 116707: c7 40 30 01 00 00 00 movl $0x1,0x30(%eax) <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; return; } _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; 11670e: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED executing->Wait.id = id; 116711: 89 7a 20 mov %edi,0x20(%edx) <== NOT EXECUTED executing->Wait.return_argument_second.mutable_object = buffer; 116714: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 116717: 89 7a 2c mov %edi,0x2c(%edx) <== NOT EXECUTED executing->Wait.return_argument = size_p; 11671a: 89 4a 28 mov %ecx,0x28(%edx) <== NOT EXECUTED /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 11671d: 56 push %esi <== NOT EXECUTED 11671e: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 11671f: c7 45 10 94 19 11 00 movl $0x111994,0x10(%ebp) <== NOT EXECUTED 116726: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 116729: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 11672c: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 11672f: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED } 116732: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116735: 5b pop %ebx <== NOT EXECUTED 116736: 5e pop %esi <== NOT EXECUTED 116737: 5f pop %edi <== NOT EXECUTED 116738: c9 leave <== NOT EXECUTED executing->Wait.return_argument_second.mutable_object = buffer; executing->Wait.return_argument = size_p; /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 116739: e9 06 af ff ff jmp 111644 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 11673e: 66 90 xchg %ax,%ax <== NOT EXECUTED * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size 116740: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 116743: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 116746: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 116749: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 11674c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11674f: 5b pop %ebx <== NOT EXECUTED 116750: 5e pop %esi <== NOT EXECUTED 116751: 5f pop %edi <== NOT EXECUTED 116752: c9 leave <== NOT EXECUTED 116753: e9 90 94 ff ff jmp 10fbe8 <_Chain_Append> <== NOT EXECUTED 0010ae28 <_CORE_message_queue_Submit>: CORE_message_queue_API_mp_support_callout api_message_queue_mp_support, CORE_message_queue_Submit_types submit_type, bool wait, Watchdog_Interval timeout ) { 10ae28: 55 push %ebp <== NOT EXECUTED 10ae29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae2b: 57 push %edi <== NOT EXECUTED 10ae2c: 56 push %esi <== NOT EXECUTED 10ae2d: 53 push %ebx <== NOT EXECUTED 10ae2e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10ae31: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10ae34: 8a 45 20 mov 0x20(%ebp),%al <== NOT EXECUTED 10ae37: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 10ae3a: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10ae3d: 39 53 4c cmp %edx,0x4c(%ebx) <== NOT EXECUTED 10ae40: 72 6e jb 10aeb0 <_CORE_message_queue_Submit+0x88> <== NOT EXECUTED /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { 10ae42: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10ae45: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae47: 74 77 je 10aec0 <_CORE_message_queue_Submit+0x98> <== NOT EXECUTED /* * 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 < 10ae49: 39 43 44 cmp %eax,0x44(%ebx) <== NOT EXECUTED 10ae4c: 0f 87 be 00 00 00 ja 10af10 <_CORE_message_queue_Submit+0xe8> <== NOT EXECUTED * 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 ) { 10ae52: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10ae56: 0f 84 9c 00 00 00 je 10aef8 <_CORE_message_queue_Submit+0xd0> <== NOT EXECUTED /* * 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() ) { 10ae5c: a1 58 f8 11 00 mov 0x11f858,%eax <== NOT EXECUTED 10ae61: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae63: 0f 85 97 00 00 00 jne 10af00 <_CORE_message_queue_Submit+0xd8> <== NOT EXECUTED * it as a variable. Doing this emphasizes how dangerous it * would be to use this variable prior to here. */ { Thread_Control *executing = _Thread_Executing; 10ae69: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED _ISR_Disable( level ); 10ae6e: 9c pushf <== NOT EXECUTED 10ae6f: fa cli <== NOT EXECUTED 10ae70: 5a pop %edx <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10ae71: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_message_queue->Wait_queue ); executing->Wait.queue = &the_message_queue->Wait_queue; 10ae78: 89 58 44 mov %ebx,0x44(%eax) <== NOT EXECUTED executing->Wait.id = id; 10ae7b: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 10ae7e: 89 70 20 mov %esi,0x20(%eax) <== NOT EXECUTED executing->Wait.return_argument_second.immutable_object = buffer; 10ae81: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10ae84: 89 48 2c mov %ecx,0x2c(%eax) <== NOT EXECUTED executing->Wait.option = (uint32_t) size; 10ae87: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10ae8a: 89 70 30 mov %esi,0x30(%eax) <== NOT EXECUTED executing->Wait.count = submit_type; 10ae8d: 8b 4d 1c mov 0x1c(%ebp),%ecx <== NOT EXECUTED 10ae90: 89 48 24 mov %ecx,0x24(%eax) <== NOT EXECUTED _ISR_Enable( level ); 10ae93: 52 push %edx <== NOT EXECUTED 10ae94: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 10ae95: 50 push %eax <== NOT EXECUTED 10ae96: 68 5c cb 10 00 push $0x10cb5c <== NOT EXECUTED 10ae9b: ff 75 24 pushl 0x24(%ebp) <== NOT EXECUTED 10ae9e: 53 push %ebx <== NOT EXECUTED 10ae9f: e8 68 19 00 00 call 10c80c <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 10aea4: b8 07 00 00 00 mov $0x7,%eax <== NOT EXECUTED 10aea9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aeac: eb 07 jmp 10aeb5 <_CORE_message_queue_Submit+0x8d> <== NOT EXECUTED 10aeae: 66 90 xchg %ax,%ax <== NOT EXECUTED { ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 10aeb0: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; } 10aeb5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aeb8: 5b pop %ebx <== NOT EXECUTED 10aeb9: 5e pop %esi <== NOT EXECUTED 10aeba: 5f pop %edi <== NOT EXECUTED 10aebb: c9 leave <== NOT EXECUTED 10aebc: c3 ret <== NOT EXECUTED 10aebd: 8d 76 00 lea 0x0(%esi),%esi <== 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 ); 10aec0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aec3: 53 push %ebx <== NOT EXECUTED 10aec4: e8 07 18 00 00 call 10c6d0 <_Thread_queue_Dequeue> <== NOT EXECUTED 10aec9: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( the_thread ) { 10aecb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aece: 85 c0 test %eax,%eax <== NOT EXECUTED 10aed0: 74 7e je 10af50 <_CORE_message_queue_Submit+0x128> <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 10aed2: 8b 78 2c mov 0x2c(%eax),%edi <== NOT EXECUTED 10aed5: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10aed8: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10aedb: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 10aedd: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 10aee0: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10aee3: 89 08 mov %ecx,(%eax) <== NOT EXECUTED the_thread->Wait.count = submit_type; 10aee5: 8b 75 1c mov 0x1c(%ebp),%esi <== NOT EXECUTED 10aee8: 89 72 24 mov %esi,0x24(%edx) <== NOT EXECUTED 10aeeb: 31 c0 xor %eax,%eax <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; } 10aeed: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aef0: 5b pop %ebx <== NOT EXECUTED 10aef1: 5e pop %esi <== NOT EXECUTED 10aef2: 5f pop %edi <== NOT EXECUTED 10aef3: c9 leave <== NOT EXECUTED 10aef4: c3 ret <== NOT EXECUTED 10aef5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * 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 ) { 10aef8: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10aefd: eb b6 jmp 10aeb5 <_CORE_message_queue_Submit+0x8d> <== NOT EXECUTED 10aeff: 90 nop <== NOT EXECUTED _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; 10af00: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 10af05: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10af08: 5b pop %ebx <== NOT EXECUTED 10af09: 5e pop %esi <== NOT EXECUTED 10af0a: 5f pop %edi <== NOT EXECUTED 10af0b: c9 leave <== NOT EXECUTED 10af0c: c3 ret <== NOT EXECUTED 10af0d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ); /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. 10af10: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af13: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 10af16: 50 push %eax <== NOT EXECUTED 10af17: e8 e4 fe ff ff call 10ae00 <_Chain_Get> <== NOT EXECUTED /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 10af1c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af1f: 85 c0 test %eax,%eax <== NOT EXECUTED 10af21: 74 dd je 10af00 <_CORE_message_queue_Submit+0xd8> <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 10af23: 8d 78 10 lea 0x10(%eax),%edi <== NOT EXECUTED 10af26: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10af29: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10af2c: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 10af2e: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10af31: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED the_message->priority = submit_type; 10af34: 8b 4d 1c mov 0x1c(%ebp),%ecx <== NOT EXECUTED 10af37: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED _CORE_message_queue_Insert_message( 10af3a: 52 push %edx <== NOT EXECUTED 10af3b: 51 push %ecx <== NOT EXECUTED 10af3c: 50 push %eax <== NOT EXECUTED 10af3d: 53 push %ebx <== NOT EXECUTED 10af3e: e8 d9 47 00 00 call 10f71c <_CORE_message_queue_Insert_message> <== NOT EXECUTED 10af43: 31 c0 xor %eax,%eax <== NOT EXECUTED 10af45: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af48: e9 68 ff ff ff jmp 10aeb5 <_CORE_message_queue_Submit+0x8d> <== NOT EXECUTED 10af4d: 8d 76 00 lea 0x0(%esi),%esi <== 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 ); if ( the_thread ) { 10af50: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10af53: e9 f1 fe ff ff jmp 10ae49 <_CORE_message_queue_Submit+0x21> <== NOT EXECUTED 0010af58 <_CORE_mutex_Flush>: void _CORE_mutex_Flush( CORE_mutex_Control *the_mutex, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 10af58: 55 push %ebp <== NOT EXECUTED 10af59: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Thread_queue_Flush( &the_mutex->Wait_queue, remote_extract_callout, status ); } 10af5b: c9 leave <== NOT EXECUTED CORE_mutex_Control *the_mutex, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { _Thread_queue_Flush( 10af5c: e9 f3 1a 00 00 jmp 10ca54 <_Thread_queue_Flush> <== NOT EXECUTED 0010af64 <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 10af64: 55 push %ebp <== NOT EXECUTED 10af65: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10af67: 57 push %edi <== NOT EXECUTED 10af68: 56 push %esi <== NOT EXECUTED 10af69: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10af6c: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10af6f: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED /* 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; 10af72: 8d 7a 40 lea 0x40(%edx),%edi <== NOT EXECUTED 10af75: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10af7a: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10af7d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED the_mutex->lock = initial_lock; 10af7f: 89 42 50 mov %eax,0x50(%edx) <== NOT EXECUTED the_mutex->blocked_count = 0; 10af82: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx) <== NOT EXECUTED if ( initial_lock == CORE_MUTEX_LOCKED ) { 10af89: 85 c0 test %eax,%eax <== NOT EXECUTED 10af8b: 75 33 jne 10afc0 <_CORE_mutex_Initialize+0x5c> <== NOT EXECUTED the_mutex->nest_count = 1; 10af8d: c7 42 54 01 00 00 00 movl $0x1,0x54(%edx) <== NOT EXECUTED the_mutex->holder = _Thread_Executing; 10af94: 8b 0d 7c f8 11 00 mov 0x11f87c,%ecx <== NOT EXECUTED 10af9a: 89 4a 5c mov %ecx,0x5c(%edx) <== NOT EXECUTED the_mutex->holder_id = _Thread_Executing->Object.id; 10af9d: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10afa0: 89 42 60 mov %eax,0x60(%edx) <== NOT EXECUTED /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. * Any other value of @a alignment is taken "as is", i.e., even odd 10afa3: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 10afa6: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10afa9: 74 05 je 10afb0 <_CORE_mutex_Initialize+0x4c> <== NOT EXECUTED 10afab: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10afae: 75 25 jne 10afd5 <_CORE_mutex_Initialize+0x71> <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 10afb0: 8b 41 14 mov 0x14(%ecx),%eax <== NOT EXECUTED 10afb3: 3b 42 4c cmp 0x4c(%edx),%eax <== NOT EXECUTED 10afb6: 72 48 jb 10b000 <_CORE_mutex_Initialize+0x9c> <== NOT EXECUTED _Chain_Prepend_unprotected( &_Thread_Executing->lock_mutex, &the_mutex->queue.lock_queue ); the_mutex->queue.priority_before = _Thread_Executing->current_priority; #endif _Thread_Executing->resource_count++; 10afb8: ff 41 1c incl 0x1c(%ecx) <== NOT EXECUTED 10afbb: eb 18 jmp 10afd5 <_CORE_mutex_Initialize+0x71> <== NOT EXECUTED 10afbd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } } else { the_mutex->nest_count = 0; 10afc0: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) <== NOT EXECUTED the_mutex->holder = NULL; 10afc7: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx) <== NOT EXECUTED the_mutex->holder_id = 0; 10afce: c7 42 60 00 00 00 00 movl $0x0,0x60(%edx) <== NOT EXECUTED } _Thread_queue_Initialize( 10afd5: 6a 05 push $0x5 <== NOT EXECUTED 10afd7: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 10afdc: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10afdf: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10afe2: 85 c0 test %eax,%eax <== NOT EXECUTED 10afe4: 0f 95 c0 setne %al <== NOT EXECUTED 10afe7: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10afea: 50 push %eax <== NOT EXECUTED 10afeb: 52 push %edx <== NOT EXECUTED 10afec: e8 8f 1a 00 00 call 10ca80 <_Thread_queue_Initialize> <== NOT EXECUTED 10aff1: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aff3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10aff6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10aff9: 5e pop %esi <== NOT EXECUTED 10affa: 5f pop %edi <== NOT EXECUTED 10affb: c9 leave <== NOT EXECUTED 10affc: c3 ret <== NOT EXECUTED 10affd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_mutex->holder = _Thread_Executing; the_mutex->holder_id = _Thread_Executing->Object.id; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 10b000: b8 06 00 00 00 mov $0x6,%eax <== NOT EXECUTED STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10b005: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b008: 5e pop %esi <== NOT EXECUTED 10b009: 5f pop %edi <== NOT EXECUTED 10b00a: c9 leave <== NOT EXECUTED 10b00b: c3 ret <== NOT EXECUTED 0010b05c <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10b05c: 55 push %ebp <== NOT EXECUTED 10b05d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b05f: 56 push %esi <== NOT EXECUTED 10b060: 53 push %ebx <== NOT EXECUTED 10b061: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b064: 8a 5d 10 mov 0x10(%ebp),%bl <== NOT EXECUTED _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10b067: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10b06c: 85 c0 test %eax,%eax <== NOT EXECUTED 10b06e: 74 04 je 10b074 <_CORE_mutex_Seize+0x18> <== NOT EXECUTED 10b070: 84 db test %bl,%bl <== NOT EXECUTED 10b072: 75 30 jne 10b0a4 <_CORE_mutex_Seize+0x48> <== NOT EXECUTED 10b074: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b077: 8d 45 18 lea 0x18(%ebp),%eax <== NOT EXECUTED 10b07a: 50 push %eax <== NOT EXECUTED 10b07b: 56 push %esi <== NOT EXECUTED 10b07c: e8 7b 47 00 00 call 10f7fc <_CORE_mutex_Seize_interrupt_trylock> <== NOT EXECUTED 10b081: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b084: 85 c0 test %eax,%eax <== NOT EXECUTED 10b086: 74 14 je 10b09c <_CORE_mutex_Seize+0x40> <== NOT EXECUTED 10b088: 84 db test %bl,%bl <== NOT EXECUTED 10b08a: 75 30 jne 10b0bc <_CORE_mutex_Seize+0x60> <== NOT EXECUTED 10b08c: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10b08f: 9d popf <== NOT EXECUTED 10b090: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED 10b095: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) <== NOT EXECUTED } 10b09c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b09f: 5b pop %ebx <== NOT EXECUTED 10b0a0: 5e pop %esi <== NOT EXECUTED 10b0a1: c9 leave <== NOT EXECUTED 10b0a2: c3 ret <== NOT EXECUTED 10b0a3: 90 nop <== NOT EXECUTED bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10b0a4: 83 3d 84 f9 11 00 01 cmpl $0x1,0x11f984 <== NOT EXECUTED 10b0ab: 76 c7 jbe 10b074 <_CORE_mutex_Seize+0x18> <== NOT EXECUTED 10b0ad: 53 push %ebx <== NOT EXECUTED 10b0ae: 6a 13 push $0x13 <== NOT EXECUTED 10b0b0: 6a 00 push $0x0 <== NOT EXECUTED 10b0b2: 6a 00 push $0x0 <== NOT EXECUTED 10b0b4: e8 c7 04 00 00 call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 10b0b9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10b0bc: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) <== NOT EXECUTED 10b0c3: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED 10b0c8: 89 70 44 mov %esi,0x44(%eax) <== NOT EXECUTED 10b0cb: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10b0ce: 89 50 20 mov %edx,0x20(%eax) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10b0d1: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10b0d6: 40 inc %eax <== NOT EXECUTED 10b0d7: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED 10b0dc: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10b0df: 9d popf <== NOT EXECUTED 10b0e0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b0e3: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10b0e6: 56 push %esi <== NOT EXECUTED 10b0e7: e8 20 ff ff ff call 10b00c <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 10b0ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b0ef: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b0f2: 5b pop %ebx <== NOT EXECUTED 10b0f3: 5e pop %esi <== NOT EXECUTED 10b0f4: c9 leave <== NOT EXECUTED 10b0f5: c3 ret <== NOT EXECUTED 0010b00c <_CORE_mutex_Seize_interrupt_blocking>: void _CORE_mutex_Seize_interrupt_blocking( CORE_mutex_Control *the_mutex, Watchdog_Interval timeout ) { 10b00c: 55 push %ebp <== NOT EXECUTED 10b00d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b00f: 56 push %esi <== NOT EXECUTED 10b010: 53 push %ebx <== NOT EXECUTED 10b011: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b014: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 10b017: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 10b01c: 83 7b 48 02 cmpl $0x2,0x48(%ebx) <== NOT EXECUTED 10b020: 74 1e je 10b040 <_CORE_mutex_Seize_interrupt_blocking+0x34> <== NOT EXECUTED FALSE ); } } the_mutex->blocked_count++; 10b022: ff 43 58 incl 0x58(%ebx) <== NOT EXECUTED _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 10b025: 50 push %eax <== NOT EXECUTED 10b026: 68 5c cb 10 00 push $0x10cb5c <== NOT EXECUTED 10b02b: 56 push %esi <== NOT EXECUTED 10b02c: 53 push %ebx <== NOT EXECUTED 10b02d: e8 da 17 00 00 call 10c80c <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b032: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b035: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b038: 5b pop %ebx <== NOT EXECUTED 10b039: 5e pop %esi <== NOT EXECUTED 10b03a: c9 leave <== NOT EXECUTED } the_mutex->blocked_count++; _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); _Thread_Enable_dispatch(); 10b03b: e9 0c 13 00 00 jmp 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED { Thread_Control *executing; executing = _Thread_Executing; if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { if ( the_mutex->holder->current_priority > executing->current_priority ) { 10b040: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED 10b043: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10b046: 39 42 14 cmp %eax,0x14(%edx) <== NOT EXECUTED 10b049: 76 d7 jbe 10b022 <_CORE_mutex_Seize_interrupt_blocking+0x16> <== NOT EXECUTED _Thread_Change_priority( 10b04b: 51 push %ecx <== NOT EXECUTED 10b04c: 6a 00 push $0x0 <== NOT EXECUTED 10b04e: 50 push %eax <== NOT EXECUTED 10b04f: 52 push %edx <== NOT EXECUTED 10b050: e8 1b 0e 00 00 call 10be70 <_Thread_Change_priority> <== NOT EXECUTED 10b055: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b058: eb c8 jmp 10b022 <_CORE_mutex_Seize_interrupt_blocking+0x16> <== NOT EXECUTED 0010f7fc <_CORE_mutex_Seize_interrupt_trylock>: #if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__) int _CORE_mutex_Seize_interrupt_trylock( CORE_mutex_Control *the_mutex, ISR_Level *level_p ) { 10f7fc: 55 push %ebp <== NOT EXECUTED 10f7fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f7ff: 53 push %ebx <== NOT EXECUTED 10f800: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10f803: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ); 10f806: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f809: 8b 18 mov (%eax),%ebx <== NOT EXECUTED /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * 10f80b: 8b 15 7c f8 11 00 mov 0x11f87c,%edx <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10f811: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10f818: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 10f81b: 85 c0 test %eax,%eax <== NOT EXECUTED 10f81d: 74 2d je 10f84c <_CORE_mutex_Seize_interrupt_trylock+0x50> <== NOT EXECUTED * to be resized 10f81f: c7 41 50 00 00 00 00 movl $0x0,0x50(%ecx) <== NOT EXECUTED * @param[in] size is the new size 10f826: 89 51 5c mov %edx,0x5c(%ecx) <== NOT EXECUTED * 10f829: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10f82c: 89 41 60 mov %eax,0x60(%ecx) <== NOT EXECUTED * @return TRUE if successfully able to resize the block. 10f82f: c7 41 54 01 00 00 00 movl $0x1,0x54(%ecx) <== NOT EXECUTED /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. * Any other value of @a alignment is taken "as is", i.e., even odd 10f836: 8b 41 48 mov 0x48(%ecx),%eax <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block * to be resized * @param[in] size is the new size * * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. 10f839: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10f83c: 74 1e je 10f85c <_CORE_mutex_Seize_interrupt_trylock+0x60> <== NOT EXECUTED 10f83e: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10f841: 74 19 je 10f85c <_CORE_mutex_Seize_interrupt_trylock+0x60> <== NOT EXECUTED /** * This routine returns the block of memory which begins * at @a starting_address to @a the_heap. Any coalescing which is * possible with the freeing of this routine is performed. * * @param[in] the_heap is the heap to operate upon 10f843: 53 push %ebx <== NOT EXECUTED 10f844: 9d popf <== NOT EXECUTED 10f845: 31 c0 xor %eax,%eax <== NOT EXECUTED return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 10f847: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f84a: c9 leave <== NOT EXECUTED 10f84b: c3 ret <== NOT EXECUTED * in the specified heap. * * @param[in] the_heap pointer to heap header. * @param[in] info pointer to the free block information. * * @return free block information filled in. 10f84c: 3b 51 5c cmp 0x5c(%ecx),%edx <== NOT EXECUTED 10f84f: 74 3f je 10f890 <_CORE_mutex_Seize_interrupt_trylock+0x94> <== NOT EXECUTED Heap_Control *the_heap, Heap_Information *info ); #ifdef __cplusplus } 10f851: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10f856: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f859: c9 leave <== NOT EXECUTED 10f85a: c3 ret <== NOT EXECUTED 10f85b: 90 nop <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10f85c: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is * possible with the freeing of this routine is performed. * 10f85f: 83 79 48 03 cmpl $0x3,0x48(%ecx) <== NOT EXECUTED 10f863: 75 de jne 10f843 <_CORE_mutex_Seize_interrupt_trylock+0x47> <== NOT EXECUTED void *start_address ); /** * This routine walks the heap to verify its integrity. * 10f865: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10f868: 39 41 4c cmp %eax,0x4c(%ecx) <== NOT EXECUTED 10f86b: 74 47 je 10f8b4 <_CORE_mutex_Seize_interrupt_trylock+0xb8> <== NOT EXECUTED * @param[in] source is a user specified integer which may be used to * indicate where in the application this was invoked from * @param[in] do_dump is set to TRUE if errors should be printed * @return TRUE if the test passed fine, FALSE otherwise. */ 10f86d: 72 4d jb 10f8bc <_CORE_mutex_Seize_interrupt_trylock+0xc0> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area 10f86f: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) <== NOT EXECUTED * 10f876: c7 41 50 01 00 00 00 movl $0x1,0x50(%ecx) <== NOT EXECUTED * @return true if successfully able to return information 10f87d: c7 41 54 00 00 00 00 movl $0x0,0x54(%ecx) <== NOT EXECUTED */ 10f884: ff 4a 1c decl 0x1c(%edx) <== NOT EXECUTED bool _Protected_heap_Get_information( 10f887: 53 push %ebx <== NOT EXECUTED 10f888: 9d popf <== NOT EXECUTED 10f889: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f88b: eb c9 jmp 10f856 <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 10f88d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * * @param[in] the_heap pointer to heap header. * @param[in] info pointer to the free block information. * * @return free block information filled in. */ 10f890: 8b 41 40 mov 0x40(%ecx),%eax <== NOT EXECUTED 10f893: 85 c0 test %eax,%eax <== NOT EXECUTED 10f895: 74 11 je 10f8a8 <_CORE_mutex_Seize_interrupt_trylock+0xac> <== NOT EXECUTED 10f897: 48 dec %eax <== NOT EXECUTED 10f898: 75 b7 jne 10f851 <_CORE_mutex_Seize_interrupt_trylock+0x55> <== NOT EXECUTED bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ); #ifdef __cplusplus 10f89a: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) <== NOT EXECUTED } 10f8a1: 53 push %ebx <== NOT EXECUTED 10f8a2: 9d popf <== NOT EXECUTED 10f8a3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f8a5: eb af jmp 10f856 <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 10f8a7: 90 nop <== NOT EXECUTED * @param[in] info pointer to the free block information. * * @return free block information filled in. */ bool _Protected_heap_Get_free_information( Heap_Control *the_heap, 10f8a8: ff 41 54 incl 0x54(%ecx) <== NOT EXECUTED Heap_Information *info 10f8ab: 53 push %ebx <== NOT EXECUTED 10f8ac: 9d popf <== NOT EXECUTED 10f8ad: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f8af: eb a5 jmp 10f856 <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 10f8b1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /** * This routine walks the heap to verify its integrity. * * @param[in] the_heap is the heap to operate upon * @param[in] source is a user specified integer which may be used to 10f8b4: 53 push %ebx <== NOT EXECUTED 10f8b5: 9d popf <== NOT EXECUTED 10f8b6: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f8b8: eb 9c jmp 10f856 <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 10f8ba: 66 90 xchg %ax,%ax <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10f8bc: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10f8c1: 40 inc %eax <== NOT EXECUTED 10f8c2: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED * indicate where in the application this was invoked from * @param[in] do_dump is set to TRUE if errors should be printed * @return TRUE if the test passed fine, FALSE otherwise. */ bool _Protected_heap_Walk( Heap_Control *the_heap, 10f8c7: 53 push %ebx <== NOT EXECUTED 10f8c8: 9d popf <== NOT EXECUTED int source, 10f8c9: 50 push %eax <== NOT EXECUTED 10f8ca: 6a 00 push $0x0 <== NOT EXECUTED 10f8cc: ff 71 4c pushl 0x4c(%ecx) <== NOT EXECUTED 10f8cf: ff 71 5c pushl 0x5c(%ecx) <== NOT EXECUTED 10f8d2: e8 99 c5 ff ff call 10be70 <_Thread_Change_priority> <== NOT EXECUTED bool do_dump ); /** * This routine walks the heap and tots up the free and allocated 10f8d7: e8 70 ca ff ff call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED 10f8dc: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f8de: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f8e1: e9 70 ff ff ff jmp 10f856 <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 0010b0f8 <_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 ) { 10b0f8: 55 push %ebp <== NOT EXECUTED 10b0f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b0fb: 53 push %ebx <== NOT EXECUTED 10b0fc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b0ff: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Thread_Control *the_thread; Thread_Control *holder; #ifdef __RTEMS_STRICT_ORDER_MUTEX__ Chain_Node *first_node; #endif holder = the_mutex->holder; 10b102: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED * 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 ) { 10b105: 80 7b 44 00 cmpb $0x0,0x44(%ebx) <== NOT EXECUTED 10b109: 74 15 je 10b120 <_CORE_mutex_Surrender+0x28> <== NOT EXECUTED if ( !_Thread_Is_executing( holder ) ) 10b10b: 3b 15 7c f8 11 00 cmp 0x11f87c,%edx <== NOT EXECUTED 10b111: 74 0d je 10b120 <_CORE_mutex_Surrender+0x28> <== NOT EXECUTED 10b113: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 10b118: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b11b: c9 leave <== NOT EXECUTED 10b11c: c3 ret <== NOT EXECUTED 10b11d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 10b120: 8b 43 54 mov 0x54(%ebx),%eax <== NOT EXECUTED 10b123: 85 c0 test %eax,%eax <== NOT EXECUTED 10b125: 74 69 je 10b190 <_CORE_mutex_Surrender+0x98> <== NOT EXECUTED return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 10b127: 48 dec %eax <== NOT EXECUTED 10b128: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED if ( the_mutex->nest_count != 0 ) { 10b12b: 85 c0 test %eax,%eax <== NOT EXECUTED 10b12d: 75 69 jne 10b198 <_CORE_mutex_Surrender+0xa0> <== NOT EXECUTED /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. * Any other value of @a alignment is taken "as is", i.e., even odd 10b12f: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED /* * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 10b132: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b135: 0f 84 91 00 00 00 je 10b1cc <_CORE_mutex_Surrender+0xd4> <== NOT EXECUTED 10b13b: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b13e: 0f 84 88 00 00 00 je 10b1cc <_CORE_mutex_Surrender+0xd4> <== NOT EXECUTED } first_node = _Chain_Get_first_unprotected(&holder->lock_mutex); #endif holder->resource_count--; } the_mutex->holder = NULL; 10b144: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = 0; 10b14b: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED /* * 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 ) || 10b152: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b155: 74 55 je 10b1ac <_CORE_mutex_Surrender+0xb4> <== NOT EXECUTED 10b157: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b15a: 74 50 je 10b1ac <_CORE_mutex_Surrender+0xb4> <== NOT EXECUTED /* * Now we check if another thread was waiting for this mutex. If so, * transfer the mutex to that thread. */ if ( ( the_thread = _Thread_queue_Dequeue( &the_mutex->Wait_queue ) ) ) { 10b15c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b15f: 53 push %ebx <== NOT EXECUTED 10b160: e8 6b 15 00 00 call 10c6d0 <_Thread_queue_Dequeue> <== NOT EXECUTED 10b165: 89 c2 mov %eax,%edx <== NOT EXECUTED 10b167: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b16a: 85 c0 test %eax,%eax <== NOT EXECUTED 10b16c: 0f 84 8e 00 00 00 je 10b200 <_CORE_mutex_Surrender+0x108> <== NOT EXECUTED } else #endif { the_mutex->holder = the_thread; 10b172: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = the_thread->Object.id; 10b175: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10b178: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED the_mutex->nest_count = 1; 10b17b: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) <== NOT EXECUTED switch ( the_mutex->Attributes.discipline ) { 10b182: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10b185: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b188: 74 6a je 10b1f4 <_CORE_mutex_Surrender+0xfc> <== NOT EXECUTED 10b18a: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b18d: 74 45 je 10b1d4 <_CORE_mutex_Surrender+0xdc> <== NOT EXECUTED 10b18f: 90 nop <== NOT EXECUTED } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 10b190: 31 c0 xor %eax,%eax <== NOT EXECUTED return CORE_MUTEX_STATUS_SUCCESSFUL; } 10b192: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b195: c9 leave <== NOT EXECUTED 10b196: c3 ret <== NOT EXECUTED 10b197: 90 nop <== NOT EXECUTED return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; if ( the_mutex->nest_count != 0 ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 10b198: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10b19b: 85 c0 test %eax,%eax <== NOT EXECUTED 10b19d: 74 f1 je 10b190 <_CORE_mutex_Surrender+0x98> <== NOT EXECUTED 10b19f: 48 dec %eax <== NOT EXECUTED 10b1a0: 75 8d jne 10b12f <_CORE_mutex_Surrender+0x37> <== NOT EXECUTED 10b1a2: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10b1a7: e9 6c ff ff ff jmp 10b118 <_CORE_mutex_Surrender+0x20> <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { #ifdef __RTEMS_STRICT_ORDER_MUTEX__ if(the_mutex->queue.priority_before != holder->current_priority) _Thread_Change_priority(holder,the_mutex->queue.priority_before,TRUE); #endif if ( holder->resource_count == 0 && 10b1ac: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 10b1af: 85 c0 test %eax,%eax <== NOT EXECUTED 10b1b1: 75 a9 jne 10b15c <_CORE_mutex_Surrender+0x64> <== NOT EXECUTED 10b1b3: 8b 42 18 mov 0x18(%edx),%eax <== NOT EXECUTED 10b1b6: 3b 42 14 cmp 0x14(%edx),%eax <== NOT EXECUTED 10b1b9: 74 a1 je 10b15c <_CORE_mutex_Surrender+0x64> <== NOT EXECUTED holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 10b1bb: 51 push %ecx <== NOT EXECUTED 10b1bc: 6a 01 push $0x1 <== NOT EXECUTED 10b1be: 50 push %eax <== NOT EXECUTED 10b1bf: 52 push %edx <== NOT EXECUTED 10b1c0: e8 ab 0c 00 00 call 10be70 <_Thread_Change_priority> <== NOT EXECUTED 10b1c5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b1c8: eb 92 jmp 10b15c <_CORE_mutex_Surrender+0x64> <== NOT EXECUTED 10b1ca: 66 90 xchg %ax,%ax <== NOT EXECUTED the_mutex->nest_count++; return CORE_MUTEX_RELEASE_NOT_ORDER; } first_node = _Chain_Get_first_unprotected(&holder->lock_mutex); #endif holder->resource_count--; 10b1cc: ff 4a 1c decl 0x1c(%edx) <== NOT EXECUTED 10b1cf: e9 70 ff ff ff jmp 10b144 <_CORE_mutex_Surrender+0x4c> <== NOT EXECUTED case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: #ifdef __RTEMS_STRICT_ORDER_MUTEX__ _Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue); the_mutex->queue.priority_before = the_thread->current_priority; #endif the_thread->resource_count++; 10b1d4: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED if (the_mutex->Attributes.priority_ceiling < 10b1d7: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10b1da: 3b 42 14 cmp 0x14(%edx),%eax <== NOT EXECUTED 10b1dd: 73 b1 jae 10b190 <_CORE_mutex_Surrender+0x98> <== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 10b1df: 51 push %ecx <== NOT EXECUTED 10b1e0: 6a 00 push $0x0 <== NOT EXECUTED 10b1e2: 50 push %eax <== NOT EXECUTED 10b1e3: 52 push %edx <== NOT EXECUTED 10b1e4: e8 87 0c 00 00 call 10be70 <_Thread_Change_priority> <== NOT EXECUTED 10b1e9: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b1eb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b1ee: e9 25 ff ff ff jmp 10b118 <_CORE_mutex_Surrender+0x20> <== NOT EXECUTED 10b1f3: 90 nop <== NOT EXECUTED case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: #ifdef __RTEMS_STRICT_ORDER_MUTEX__ _Chain_Prepend_unprotected(&the_thread->lock_mutex,&the_mutex->queue.lock_queue); the_mutex->queue.priority_before = the_thread->current_priority; #endif the_thread->resource_count++; 10b1f4: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED 10b1f7: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b1f9: e9 1a ff ff ff jmp 10b118 <_CORE_mutex_Surrender+0x20> <== NOT EXECUTED 10b1fe: 66 90 xchg %ax,%ax <== NOT EXECUTED } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 10b200: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx) <== NOT EXECUTED 10b207: 31 c0 xor %eax,%eax 10b209: e9 0a ff ff ff jmp 10b118 <_CORE_mutex_Surrender+0x20> <== NOT EXECUTED 0010b210 <_CORE_semaphore_Flush>: void _CORE_semaphore_Flush( CORE_semaphore_Control *the_semaphore, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 10b210: 55 push %ebp <== NOT EXECUTED 10b211: 89 e5 mov %esp,%ebp <== NOT EXECUTED &the_semaphore->Wait_queue, remote_extract_callout, status ); } 10b213: c9 leave <== NOT EXECUTED Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { _Thread_queue_Flush( 10b214: e9 3b 18 00 00 jmp 10ca54 <_Thread_queue_Flush> <== NOT EXECUTED 0010b21c <_CORE_semaphore_Initialize>: void _CORE_semaphore_Initialize( CORE_semaphore_Control *the_semaphore, CORE_semaphore_Attributes *the_semaphore_attributes, uint32_t initial_value ) { 10b21c: 55 push %ebp <== NOT EXECUTED 10b21d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b21f: 53 push %ebx <== NOT EXECUTED 10b220: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b223: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b226: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED the_semaphore->Attributes = *the_semaphore_attributes; 10b229: 8b 1a mov (%edx),%ebx <== NOT EXECUTED 10b22b: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10b22e: 89 41 44 mov %eax,0x44(%ecx) <== NOT EXECUTED 10b231: 89 59 40 mov %ebx,0x40(%ecx) <== NOT EXECUTED the_semaphore->count = initial_value; 10b234: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b237: 89 41 48 mov %eax,0x48(%ecx) <== NOT EXECUTED _Thread_queue_Initialize( 10b23a: 6a 03 push $0x3 <== NOT EXECUTED 10b23c: 68 00 02 00 00 push $0x200 <== NOT EXECUTED 10b241: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b243: 83 7a 04 01 cmpl $0x1,0x4(%edx) <== NOT EXECUTED 10b247: 0f 94 c0 sete %al <== NOT EXECUTED 10b24a: 50 push %eax <== NOT EXECUTED 10b24b: 51 push %ecx <== NOT EXECUTED 10b24c: e8 2f 18 00 00 call 10ca80 <_Thread_queue_Initialize> <== NOT EXECUTED 10b251: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _CORE_semaphore_Is_priority( the_semaphore_attributes ) ? THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_SEMAPHORE, CORE_SEMAPHORE_TIMEOUT ); } 10b254: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b257: c9 leave <== NOT EXECUTED 10b258: c3 ret <== NOT EXECUTED 00112f88 <_CORE_semaphore_Seize>: CORE_semaphore_Control *the_semaphore, Objects_Id id, bool wait, Watchdog_Interval timeout ) { 112f88: 55 push %ebp <== NOT EXECUTED 112f89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112f8b: 57 push %edi <== NOT EXECUTED 112f8c: 56 push %esi <== NOT EXECUTED 112f8d: 53 push %ebx <== NOT EXECUTED 112f8e: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 112f91: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 112f94: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 112f97: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 112f9a: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 112f9d: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 112fa0: 8b 15 9c 59 12 00 mov 0x12599c,%edx <== NOT EXECUTED executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; 112fa6: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED _ISR_Disable( level ); 112fad: 9c pushf <== NOT EXECUTED 112fae: fa cli <== NOT EXECUTED 112faf: 5b pop %ebx <== NOT EXECUTED if ( the_semaphore->count != 0 ) { 112fb0: 8b 41 48 mov 0x48(%ecx),%eax <== NOT EXECUTED 112fb3: 85 c0 test %eax,%eax <== NOT EXECUTED 112fb5: 75 15 jne 112fcc <_CORE_semaphore_Seize+0x44> <== NOT EXECUTED /* * If the semaphore was not available and the caller was not willing * to block, then return immediately with a status indicating that * the semaphore was not available and the caller never blocked. */ if ( !wait ) { 112fb7: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 112fbb: 75 1b jne 112fd8 <_CORE_semaphore_Seize+0x50> <== NOT EXECUTED _ISR_Enable( level ); 112fbd: 53 push %ebx <== NOT EXECUTED 112fbe: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT; 112fbf: c7 42 34 01 00 00 00 movl $0x1,0x34(%edx) <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); } 112fc6: 58 pop %eax <== NOT EXECUTED 112fc7: 5b pop %ebx <== NOT EXECUTED 112fc8: 5e pop %esi <== NOT EXECUTED 112fc9: 5f pop %edi <== NOT EXECUTED 112fca: c9 leave <== NOT EXECUTED 112fcb: c3 ret <== NOT EXECUTED executing = _Thread_Executing; executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL; _ISR_Disable( level ); if ( the_semaphore->count != 0 ) { the_semaphore->count -= 1; 112fcc: 48 dec %eax <== NOT EXECUTED 112fcd: 89 41 48 mov %eax,0x48(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 112fd0: 53 push %ebx <== NOT EXECUTED 112fd1: 9d popf <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); } 112fd2: 58 pop %eax <== NOT EXECUTED 112fd3: 5b pop %ebx <== NOT EXECUTED 112fd4: 5e pop %esi <== NOT EXECUTED 112fd5: 5f pop %edi <== NOT EXECUTED 112fd6: c9 leave <== NOT EXECUTED 112fd7: c3 ret <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 112fd8: c7 41 30 01 00 00 00 movl $0x1,0x30(%ecx) <== NOT EXECUTED /* * If the semaphore is not available and the caller is willing to * block, then we now block the caller with optional timeout. */ _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; 112fdf: 89 4a 44 mov %ecx,0x44(%edx) <== NOT EXECUTED executing->Wait.id = id; 112fe2: 89 72 20 mov %esi,0x20(%edx) <== NOT EXECUTED _ISR_Enable( level ); 112fe5: 53 push %ebx <== NOT EXECUTED 112fe6: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 112fe7: c7 45 10 74 fb 10 00 movl $0x10fb74,0x10(%ebp) <== NOT EXECUTED 112fee: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 112ff1: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 112ff4: 5a pop %edx <== NOT EXECUTED 112ff5: 5b pop %ebx <== NOT EXECUTED 112ff6: 5e pop %esi <== NOT EXECUTED 112ff7: 5f pop %edi <== NOT EXECUTED 112ff8: c9 leave <== NOT EXECUTED */ _Thread_queue_Enter_critical_section( &the_semaphore->Wait_queue ); executing->Wait.queue = &the_semaphore->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_semaphore->Wait_queue, timeout ); 112ff9: e9 26 c8 ff ff jmp 10f824 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 0010b25c <_CORE_semaphore_Surrender>: CORE_semaphore_Status _CORE_semaphore_Surrender( CORE_semaphore_Control *the_semaphore, Objects_Id id, CORE_semaphore_API_mp_support_callout api_semaphore_mp_support ) { 10b25c: 55 push %ebp <== NOT EXECUTED 10b25d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b25f: 53 push %ebx <== NOT EXECUTED 10b260: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10b263: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 10b266: 53 push %ebx <== NOT EXECUTED 10b267: e8 64 14 00 00 call 10c6d0 <_Thread_queue_Dequeue> <== NOT EXECUTED 10b26c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b26f: 85 c0 test %eax,%eax <== NOT EXECUTED 10b271: 74 09 je 10b27c <_CORE_semaphore_Surrender+0x20> <== NOT EXECUTED 10b273: 31 c0 xor %eax,%eax <== NOT EXECUTED status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); } return status; } 10b275: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b278: c9 leave <== NOT EXECUTED 10b279: c3 ret <== NOT EXECUTED 10b27a: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); 10b27c: 9c pushf <== NOT EXECUTED 10b27d: fa cli <== NOT EXECUTED 10b27e: 5a pop %edx <== NOT EXECUTED if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10b27f: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10b282: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10b285: 72 0d jb 10b294 <_CORE_semaphore_Surrender+0x38> <== NOT EXECUTED 10b287: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); 10b28c: 52 push %edx <== NOT EXECUTED 10b28d: 9d popf <== NOT EXECUTED } return status; } 10b28e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b291: c9 leave <== NOT EXECUTED 10b292: c3 ret <== NOT EXECUTED 10b293: 90 nop <== NOT EXECUTED #endif } else { _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) the_semaphore->count += 1; 10b294: 40 inc %eax <== NOT EXECUTED 10b295: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 10b298: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b29a: eb f0 jmp 10b28c <_CORE_semaphore_Surrender+0x30> <== NOT EXECUTED 0010bbc0 <_CORE_spinlock_Initialize>: void _CORE_spinlock_Initialize( CORE_spinlock_Control *the_spinlock, CORE_spinlock_Attributes *the_spinlock_attributes ) { 10bbc0: 55 push %ebp <== NOT EXECUTED 10bbc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bbc3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED the_spinlock->Attributes = *the_spinlock_attributes; 10bbc6: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10bbc9: 8b 12 mov (%edx),%edx <== NOT EXECUTED 10bbcb: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_spinlock->lock = 0; 10bbcd: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED the_spinlock->users = 0; 10bbd4: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax) <== NOT EXECUTED the_spinlock->holder = 0; 10bbdb: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED } 10bbe2: c9 leave <== NOT EXECUTED 10bbe3: c3 ret <== NOT EXECUTED 0010bbe4 <_CORE_spinlock_Release>: */ CORE_spinlock_Status _CORE_spinlock_Release( CORE_spinlock_Control *the_spinlock ) { 10bbe4: 55 push %ebp <== NOT EXECUTED 10bbe5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bbe7: 53 push %ebx <== NOT EXECUTED 10bbe8: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10bbeb: 9c pushf <== NOT EXECUTED 10bbec: fa cli <== NOT EXECUTED 10bbed: 59 pop %ecx <== NOT EXECUTED /* * It must locked before it can be unlocked. */ if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 10bbee: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10bbf1: 85 c0 test %eax,%eax <== NOT EXECUTED 10bbf3: 75 07 jne 10bbfc <_CORE_spinlock_Release+0x18> <== NOT EXECUTED _ISR_Enable( level ); 10bbf5: 51 push %ecx <== NOT EXECUTED 10bbf6: 9d popf <== NOT EXECUTED 10bbf7: b0 06 mov $0x6,%al <== NOT EXECUTED the_spinlock->lock = CORE_SPINLOCK_UNLOCKED; the_spinlock->holder = 0; _ISR_Enable( level ); return CORE_SPINLOCK_SUCCESSFUL; } 10bbf9: 5b pop %ebx <== NOT EXECUTED 10bbfa: c9 leave <== NOT EXECUTED 10bbfb: c3 ret <== NOT EXECUTED } /* * It must locked by the current thread before it can be unlocked. */ if ( the_spinlock->holder != _Thread_Executing->Object.id ) { 10bbfc: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED 10bbff: a1 7c 09 12 00 mov 0x12097c,%eax <== NOT EXECUTED 10bc04: 3b 50 08 cmp 0x8(%eax),%edx <== NOT EXECUTED 10bc07: 74 0b je 10bc14 <_CORE_spinlock_Release+0x30> <== NOT EXECUTED _ISR_Enable( level ); 10bc09: 51 push %ecx <== NOT EXECUTED 10bc0a: 9d popf <== NOT EXECUTED 10bc0b: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED the_spinlock->lock = CORE_SPINLOCK_UNLOCKED; the_spinlock->holder = 0; _ISR_Enable( level ); return CORE_SPINLOCK_SUCCESSFUL; } 10bc10: 5b pop %ebx <== NOT EXECUTED 10bc11: c9 leave <== NOT EXECUTED 10bc12: c3 ret <== NOT EXECUTED 10bc13: 90 nop <== NOT EXECUTED } /* * Let it be unlocked. */ the_spinlock->users -= 1; 10bc14: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10bc17: 48 dec %eax <== NOT EXECUTED 10bc18: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED the_spinlock->lock = CORE_SPINLOCK_UNLOCKED; 10bc1b: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED the_spinlock->holder = 0; 10bc22: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10bc29: 51 push %ecx <== NOT EXECUTED 10bc2a: 9d popf <== NOT EXECUTED 10bc2b: 31 c0 xor %eax,%eax 10bc2d: eb ca jmp 10bbf9 <_CORE_spinlock_Release+0x15> <== NOT EXECUTED 0010bc30 <_CORE_spinlock_Wait>: CORE_spinlock_Status _CORE_spinlock_Wait( CORE_spinlock_Control *the_spinlock, bool wait, Watchdog_Interval timeout ) { 10bc30: 55 push %ebp <== NOT EXECUTED 10bc31: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc33: 57 push %edi <== NOT EXECUTED 10bc34: 56 push %esi <== NOT EXECUTED 10bc35: 53 push %ebx <== NOT EXECUTED 10bc36: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bc39: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bc3c: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10bc3f: 8a 45 0c mov 0xc(%ebp),%al <== NOT EXECUTED 10bc42: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED ISR_Level level; Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout; 10bc45: a1 24 0a 12 00 mov 0x120a24,%eax <== NOT EXECUTED 10bc4a: 8d 34 07 lea (%edi,%eax,1),%esi <== NOT EXECUTED _ISR_Disable( level ); 10bc4d: 9c pushf <== NOT EXECUTED 10bc4e: fa cli <== NOT EXECUTED 10bc4f: 59 pop %ecx <== NOT EXECUTED if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) && 10bc50: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10bc53: 48 dec %eax <== NOT EXECUTED 10bc54: 74 76 je 10bccc <_CORE_spinlock_Wait+0x9c> <== NOT EXECUTED (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; 10bc56: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10bc59: 40 inc %eax <== NOT EXECUTED 10bc5a: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 10bc5d: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10bc60: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc62: 74 31 je 10bc95 <_CORE_spinlock_Wait+0x65> <== NOT EXECUTED } /* * Spinlock is unavailable. If not willing to wait, return. */ if ( !wait ) { 10bc64: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10bc68: 74 49 je 10bcb3 <_CORE_spinlock_Wait+0x83> <== NOT EXECUTED 10bc6a: 66 90 xchg %ax,%ax <== NOT EXECUTED } /* * They are willing to wait but there could be a timeout. */ if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) { 10bc6c: 85 ff test %edi,%edi <== NOT EXECUTED 10bc6e: 74 09 je 10bc79 <_CORE_spinlock_Wait+0x49> <== NOT EXECUTED 10bc70: a1 24 0a 12 00 mov 0x120a24,%eax <== NOT EXECUTED 10bc75: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10bc77: 76 6f jbe 10bce8 <_CORE_spinlock_Wait+0xb8> <== NOT EXECUTED * * A spinlock cannot be deleted while it is being used so we are * safe from deletion. */ _ISR_Enable( level ); 10bc79: 51 push %ecx <== NOT EXECUTED 10bc7a: 9d popf <== NOT EXECUTED /* An ISR could occur here */ _Thread_Enable_dispatch(); 10bc7b: e8 30 11 00 00 call 10cdb0 <_Thread_Enable_dispatch> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10bc80: a1 b8 08 12 00 mov 0x1208b8,%eax <== NOT EXECUTED 10bc85: 40 inc %eax <== NOT EXECUTED 10bc86: a3 b8 08 12 00 mov %eax,0x1208b8 <== 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 ); 10bc8b: 9c pushf <== NOT EXECUTED 10bc8c: fa cli <== NOT EXECUTED 10bc8d: 59 pop %ecx <== NOT EXECUTED _ISR_Enable( level ); return CORE_SPINLOCK_HOLDER_RELOCKING; } the_spinlock->users += 1; for ( ;; ) { if ( the_spinlock->lock == CORE_SPINLOCK_UNLOCKED ) { 10bc8e: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10bc91: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc93: 75 d7 jne 10bc6c <_CORE_spinlock_Wait+0x3c> <== NOT EXECUTED the_spinlock->lock = CORE_SPINLOCK_LOCKED; 10bc95: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) <== NOT EXECUTED the_spinlock->holder = _Thread_Executing->Object.id; 10bc9c: a1 7c 09 12 00 mov 0x12097c,%eax <== NOT EXECUTED 10bca1: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10bca4: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10bca7: 51 push %ecx <== NOT EXECUTED 10bca8: 9d popf <== NOT EXECUTED 10bca9: 31 c0 xor %eax,%eax <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Disable( level ); } } 10bcab: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10bcae: 5b pop %ebx <== NOT EXECUTED 10bcaf: 5e pop %esi <== NOT EXECUTED 10bcb0: 5f pop %edi <== NOT EXECUTED 10bcb1: c9 leave <== NOT EXECUTED 10bcb2: c3 ret <== NOT EXECUTED /* * Spinlock is unavailable. If not willing to wait, return. */ if ( !wait ) { the_spinlock->users -= 1; 10bcb3: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10bcb6: 48 dec %eax <== NOT EXECUTED 10bcb7: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10bcba: 51 push %ecx <== NOT EXECUTED 10bcbb: 9d popf <== NOT EXECUTED 10bcbc: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Disable( level ); } } 10bcc1: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10bcc4: 5b pop %ebx <== NOT EXECUTED 10bcc5: 5e pop %esi <== NOT EXECUTED 10bcc6: 5f pop %edi <== NOT EXECUTED 10bcc7: c9 leave <== NOT EXECUTED 10bcc8: c3 ret <== NOT EXECUTED 10bcc9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { ISR_Level level; Watchdog_Interval limit = _Watchdog_Ticks_since_boot + timeout; _ISR_Disable( level ); if ( (the_spinlock->lock == CORE_SPINLOCK_LOCKED) && 10bccc: 8b 53 0c mov 0xc(%ebx),%edx <== NOT EXECUTED 10bccf: a1 7c 09 12 00 mov 0x12097c,%eax <== NOT EXECUTED 10bcd4: 3b 50 08 cmp 0x8(%eax),%edx <== NOT EXECUTED 10bcd7: 0f 85 79 ff ff ff jne 10bc56 <_CORE_spinlock_Wait+0x26> <== NOT EXECUTED (the_spinlock->holder == _Thread_Executing->Object.id) ) { _ISR_Enable( level ); 10bcdd: 51 push %ecx <== NOT EXECUTED 10bcde: 9d popf <== NOT EXECUTED 10bcdf: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10bce4: eb c5 jmp 10bcab <_CORE_spinlock_Wait+0x7b> <== NOT EXECUTED 10bce6: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * They are willing to wait but there could be a timeout. */ if ( timeout && (limit <= _Watchdog_Ticks_since_boot) ) { the_spinlock->users -= 1; 10bce8: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10bceb: 48 dec %eax <== NOT EXECUTED 10bcec: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10bcef: 51 push %ecx <== NOT EXECUTED 10bcf0: 9d popf <== NOT EXECUTED 10bcf1: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Disable( level ); } } 10bcf6: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10bcf9: 5b pop %ebx <== NOT EXECUTED 10bcfa: 5e pop %esi <== NOT EXECUTED 10bcfb: 5f pop %edi <== NOT EXECUTED 10bcfc: c9 leave <== NOT EXECUTED 10bcfd: c3 ret <== NOT EXECUTED 0010addc <_Chain_Append>: void _Chain_Append( Chain_Control *the_chain, Chain_Node *node ) { 10addc: 55 push %ebp <== NOT EXECUTED 10addd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10addf: 53 push %ebx <== NOT EXECUTED 10ade0: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ade3: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10ade6: 9c pushf <== NOT EXECUTED 10ade7: fa cli <== NOT EXECUTED 10ade8: 5b pop %ebx <== NOT EXECUTED 10ade9: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10adec: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10adee: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10adf1: 89 51 08 mov %edx,0x8(%ecx) <== NOT EXECUTED 10adf4: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10adf6: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED _Chain_Append_unprotected( the_chain, node ); _ISR_Enable( level ); 10adf9: 53 push %ebx <== NOT EXECUTED 10adfa: 9d popf <== NOT EXECUTED } 10adfb: 5b pop %ebx <== NOT EXECUTED 10adfc: c9 leave <== NOT EXECUTED 10adfd: c3 ret <== NOT EXECUTED 0010f6b8 <_Chain_Extract>: */ void _Chain_Extract( Chain_Node *node ) { 10f6b8: 55 push %ebp <== NOT EXECUTED 10f6b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f6bb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10f6be: 9c pushf <== NOT EXECUTED 10f6bf: fa cli <== NOT EXECUTED 10f6c0: 59 pop %ecx <== NOT EXECUTED 10f6c1: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10f6c3: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10f6c6: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10f6c9: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Extract_unprotected( node ); _ISR_Enable( level ); 10f6cb: 51 push %ecx <== NOT EXECUTED 10f6cc: 9d popf <== NOT EXECUTED } 10f6cd: c9 leave <== NOT EXECUTED 10f6ce: c3 ret <== NOT EXECUTED 0010ae00 <_Chain_Get>: */ Chain_Node *_Chain_Get( Chain_Control *the_chain ) { 10ae00: 55 push %ebp <== NOT EXECUTED 10ae01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae03: 53 push %ebx <== NOT EXECUTED 10ae04: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Chain_Node *return_node; return_node = NULL; _ISR_Disable( level ); 10ae07: 9c pushf <== NOT EXECUTED 10ae08: fa cli <== NOT EXECUTED 10ae09: 5b pop %ebx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10ae0a: 8b 11 mov (%ecx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( the_chain ) ) 10ae0c: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10ae0f: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10ae11: 74 11 je 10ae24 <_Chain_Get+0x24> <== NOT EXECUTED 10ae13: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10ae15: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10ae17: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED return_node = _Chain_Get_first_unprotected( the_chain ); _ISR_Enable( level ); 10ae1a: 53 push %ebx <== NOT EXECUTED 10ae1b: 9d popf <== NOT EXECUTED return return_node; } 10ae1c: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ae1e: 5b pop %ebx <== NOT EXECUTED 10ae1f: c9 leave <== NOT EXECUTED 10ae20: c3 ret <== NOT EXECUTED 10ae21: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ISR_Level level; Chain_Node *return_node; return_node = NULL; _ISR_Disable( level ); if ( !_Chain_Is_empty( the_chain ) ) 10ae24: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ae26: eb f2 jmp 10ae1a <_Chain_Get+0x1a> <== NOT EXECUTED 0010f6d0 <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10f6d0: 55 push %ebp <== NOT EXECUTED 10f6d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f6d3: 57 push %edi <== NOT EXECUTED 10f6d4: 56 push %esi <== NOT EXECUTED 10f6d5: 53 push %ebx <== NOT EXECUTED 10f6d6: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10f6d9: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10f6dc: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED size_t size ); /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the 10f6df: 89 f1 mov %esi,%ecx <== NOT EXECUTED Chain_Node *current; Chain_Node *next; count = number_nodes; current = _Chain_Head( the_chain ); the_chain->permanent_null = NULL; 10f6e1: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) <== NOT EXECUTED next = starting_address; while ( count-- ) { 10f6e8: 85 c0 test %eax,%eax <== NOT EXECUTED 10f6ea: 74 22 je 10f70e <_Chain_Initialize+0x3e> <== NOT EXECUTED 10f6ec: 8d 50 ff lea -0x1(%eax),%edx <== NOT EXECUTED 10f6ef: 89 d7 mov %edx,%edi <== NOT EXECUTED 10f6f1: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f6f4: eb 03 jmp 10f6f9 <_Chain_Initialize+0x29> <== NOT EXECUTED 10f6f6: 66 90 xchg %ax,%ax <== NOT EXECUTED 10f6f8: 4a dec %edx <== NOT EXECUTED current->next = next; 10f6f9: 89 01 mov %eax,(%ecx) <== NOT EXECUTED next->previous = current; 10f6fb: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10f6fe: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10f700: 01 d8 add %ebx,%eax <== NOT EXECUTED count = number_nodes; current = _Chain_Head( the_chain ); the_chain->permanent_null = NULL; next = starting_address; while ( count-- ) { 10f702: 85 d2 test %edx,%edx <== NOT EXECUTED 10f704: 75 f2 jne 10f6f8 <_Chain_Initialize+0x28> <== NOT EXECUTED 10f706: 0f af df imul %edi,%ebx <== NOT EXECUTED 10f709: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10f70c: 01 d9 add %ebx,%ecx <== NOT EXECUTED next->previous = current; current = next; next = (Chain_Node *) _Addresses_Add_offset( (void *) next, node_size ); } current->next = _Chain_Tail( the_chain ); 10f70e: 8d 46 04 lea 0x4(%esi),%eax <== NOT EXECUTED 10f711: 89 01 mov %eax,(%ecx) <== NOT EXECUTED the_chain->last = current; 10f713: 89 4e 08 mov %ecx,0x8(%esi) <== NOT EXECUTED } 10f716: 5b pop %ebx <== NOT EXECUTED 10f717: 5e pop %esi <== NOT EXECUTED 10f718: 5f pop %edi <== NOT EXECUTED 10f719: c9 leave <== NOT EXECUTED 10f71a: c3 ret <== NOT EXECUTED 00126b48 <_Chain_Insert>: void _Chain_Insert( Chain_Node *after_node, Chain_Node *node ) { 126b48: 55 push %ebp <== NOT EXECUTED 126b49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126b4b: 53 push %ebx <== NOT EXECUTED 126b4c: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 126b4f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 126b52: 9c pushf <== NOT EXECUTED 126b53: fa cli <== NOT EXECUTED 126b54: 5b pop %ebx <== NOT EXECUTED 126b55: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 126b58: 8b 0a mov (%edx),%ecx <== NOT EXECUTED 126b5a: 89 02 mov %eax,(%edx) <== NOT EXECUTED 126b5c: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 126b5e: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED _Chain_Insert_unprotected( after_node, node ); _ISR_Enable( level ); 126b61: 53 push %ebx <== NOT EXECUTED 126b62: 9d popf <== NOT EXECUTED } 126b63: 5b pop %ebx <== NOT EXECUTED 126b64: c9 leave <== NOT EXECUTED 126b65: c3 ret <== NOT EXECUTED 0010f664 <_Debug_Is_enabled>: */ bool _Debug_Is_enabled( rtems_debug_control level ) { 10f664: 55 push %ebp <== NOT EXECUTED 10f665: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f667: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10f66a: 85 05 80 f8 11 00 test %eax,0x11f880 <== NOT EXECUTED 10f670: 0f 95 c0 setne %al <== NOT EXECUTED return (_Debug_Level & level) ? true : false; } 10f673: c9 leave <== NOT EXECUTED 10f674: c3 ret <== NOT EXECUTED 0010f634 <_Debug_Manager_initialization>: * * _Debug_Manager_initialization */ void _Debug_Manager_initialization( void ) { 10f634: 55 push %ebp <== NOT EXECUTED 10f635: 89 e5 mov %esp,%ebp <== NOT EXECUTED void rtems_debug_disable ( rtems_debug_control to_be_disabled ) { _Debug_Level &= ~to_be_disabled; 10f637: c7 05 80 f8 11 00 00 movl $0x0,0x11f880 <== NOT EXECUTED 10f63e: 00 00 00 <== NOT EXECUTED */ void _Debug_Manager_initialization( void ) { rtems_debug_disable( RTEMS_DEBUG_ALL_MASK ); } 10f641: c9 leave <== NOT EXECUTED 10f642: c3 ret <== NOT EXECUTED 0010f2b4 <_Dual_ported_memory_Manager_initialization>: */ void _Dual_ported_memory_Manager_initialization( uint32_t maximum_ports ) { 10f2b4: 55 push %ebp <== NOT EXECUTED 10f2b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f2b7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f2ba: 6a 04 push $0x4 <== NOT EXECUTED 10f2bc: 6a 00 push $0x0 <== NOT EXECUTED 10f2be: 6a 1c push $0x1c <== NOT EXECUTED 10f2c0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f2c3: 6a 07 push $0x7 <== NOT EXECUTED 10f2c5: 6a 02 push $0x2 <== NOT EXECUTED 10f2c7: 68 80 02 12 00 push $0x120280 <== NOT EXECUTED 10f2cc: e8 9b c8 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f2d1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10f2d4: c9 leave <== NOT EXECUTED 10f2d5: c3 ret <== NOT EXECUTED 0010f2d8 <_Event_Manager_initialization>: * * This routine performs the initialization necessary for this manager. */ void _Event_Manager_initialization( void ) { 10f2d8: 55 push %ebp <== NOT EXECUTED 10f2d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10f2db: c7 05 80 01 12 00 00 movl $0x0,0x120180 <== NOT EXECUTED 10f2e2: 00 00 00 <== NOT EXECUTED */ #if defined(RTEMS_MULTIPROCESSING) _MPCI_Register_packet_processor( MP_PACKET_EVENT, _Event_MP_Process_packet ); #endif } 10f2e5: c9 leave <== NOT EXECUTED 10f2e6: c3 ret <== NOT EXECUTED 00109d50 <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 109d50: 55 push %ebp <== NOT EXECUTED 109d51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109d53: 57 push %edi <== NOT EXECUTED 109d54: 56 push %esi <== NOT EXECUTED 109d55: 53 push %ebx <== NOT EXECUTED 109d56: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109d59: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109d5c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 109d5f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 109d62: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED 109d65: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 109d68: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED rtems_event_set pending_events; ISR_Level level; RTEMS_API_Control *api; Thread_blocking_operation_States sync_state; executing = _Thread_Executing; 109d6b: 8b 1d 7c f8 11 00 mov 0x11f87c,%ebx <== NOT EXECUTED executing->Wait.return_code = RTEMS_SUCCESSFUL; 109d71: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED api = executing->API_Extensions[ THREAD_API_RTEMS ]; 109d78: 8b bb f4 00 00 00 mov 0xf4(%ebx),%edi <== NOT EXECUTED _ISR_Disable( level ); 109d7e: 9c pushf <== NOT EXECUTED 109d7f: fa cli <== NOT EXECUTED 109d80: 8f 45 f0 popl -0x10(%ebp) <== NOT EXECUTED pending_events = api->pending_events; 109d83: 8b 17 mov (%edi),%edx <== NOT EXECUTED seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 109d85: 89 c1 mov %eax,%ecx <== NOT EXECUTED 109d87: 21 d1 and %edx,%ecx <== NOT EXECUTED 109d89: 74 14 je 109d9f <_Event_Seize+0x4f> <== NOT EXECUTED 109d8b: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 109d8d: 0f 84 91 00 00 00 je 109e24 <_Event_Seize+0xd4> <== NOT EXECUTED 109d93: f7 c6 02 00 00 00 test $0x2,%esi <== NOT EXECUTED 109d99: 0f 85 85 00 00 00 jne 109e24 <_Event_Seize+0xd4> <== NOT EXECUTED _ISR_Enable( level ); *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { 109d9f: f7 c6 01 00 00 00 test $0x1,%esi <== NOT EXECUTED 109da5: 75 65 jne 109e0c <_Event_Seize+0xbc> <== NOT EXECUTED executing->Wait.return_code = RTEMS_UNSATISFIED; *event_out = seized_events; return; } _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 109da7: c7 05 80 01 12 00 01 movl $0x1,0x120180 <== NOT EXECUTED 109dae: 00 00 00 <== NOT EXECUTED executing->Wait.option = (uint32_t) option_set; 109db1: 89 73 30 mov %esi,0x30(%ebx) <== NOT EXECUTED executing->Wait.count = (uint32_t) event_in; 109db4: 89 43 24 mov %eax,0x24(%ebx) <== NOT EXECUTED executing->Wait.return_argument = event_out; 109db7: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 109dba: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 109dbd: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 109dc0: 9d popf <== NOT EXECUTED if ( ticks ) { 109dc1: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 109dc4: 85 c0 test %eax,%eax <== NOT EXECUTED 109dc6: 0f 85 80 00 00 00 jne 109e4c <_Event_Seize+0xfc> <== NOT EXECUTED NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 109dcc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109dcf: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 109dd4: 53 push %ebx <== NOT EXECUTED 109dd5: e8 26 2e 00 00 call 10cc00 <_Thread_Set_state> <== NOT EXECUTED _ISR_Disable( level ); 109dda: 9c pushf <== NOT EXECUTED 109ddb: fa cli <== NOT EXECUTED 109ddc: 5a pop %edx <== NOT EXECUTED sync_state = _Event_Sync_state; 109ddd: a1 80 01 12 00 mov 0x120180,%eax <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 109de2: c7 05 80 01 12 00 00 movl $0x0,0x120180 <== NOT EXECUTED 109de9: 00 00 00 <== NOT EXECUTED if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { 109dec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109def: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 109df2: 74 4c je 109e40 <_Event_Seize+0xf0> <== NOT EXECUTED * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); 109df4: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED 109df7: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 109dfa: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 109dfd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109e00: 5b pop %ebx <== NOT EXECUTED 109e01: 5e pop %esi <== NOT EXECUTED 109e02: 5f pop %edi <== NOT EXECUTED 109e03: c9 leave <== NOT EXECUTED * An interrupt completed the thread's blocking request. * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); 109e04: e9 1b 20 00 00 jmp 10be24 <_Thread_blocking_operation_Cancel> <== NOT EXECUTED 109e09: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { _ISR_Enable( level ); 109e0c: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 109e0f: 9d popf <== NOT EXECUTED executing->Wait.return_code = RTEMS_UNSATISFIED; 109e10: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx) <== NOT EXECUTED *event_out = seized_events; 109e17: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 109e1a: 89 0a mov %ecx,(%edx) <== NOT EXECUTED * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); } 109e1c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109e1f: 5b pop %ebx <== NOT EXECUTED 109e20: 5e pop %esi <== NOT EXECUTED 109e21: 5f pop %edi <== NOT EXECUTED 109e22: c9 leave <== NOT EXECUTED 109e23: c3 ret <== NOT EXECUTED pending_events = api->pending_events; seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && (seized_events == event_in || _Options_Is_any( option_set )) ) { api->pending_events = 109e24: 89 c8 mov %ecx,%eax <== NOT EXECUTED 109e26: f7 d0 not %eax <== NOT EXECUTED 109e28: 21 d0 and %edx,%eax <== NOT EXECUTED 109e2a: 89 07 mov %eax,(%edi) <== NOT EXECUTED _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 109e2c: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 109e2f: 9d popf <== NOT EXECUTED *event_out = seized_events; 109e30: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 109e33: 89 08 mov %ecx,(%eax) <== NOT EXECUTED * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); } 109e35: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109e38: 5b pop %ebx <== NOT EXECUTED 109e39: 5e pop %esi <== NOT EXECUTED 109e3a: 5f pop %edi <== NOT EXECUTED 109e3b: c9 leave <== NOT EXECUTED 109e3c: c3 ret <== NOT EXECUTED 109e3d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _ISR_Disable( level ); sync_state = _Event_Sync_state; _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { _ISR_Enable( level ); 109e40: 52 push %edx <== NOT EXECUTED 109e41: 9d popf <== NOT EXECUTED * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); } 109e42: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109e45: 5b pop %ebx <== NOT EXECUTED 109e46: 5e pop %esi <== NOT EXECUTED 109e47: 5f pop %edi <== NOT EXECUTED 109e48: c9 leave <== NOT EXECUTED 109e49: c3 ret <== NOT EXECUTED 109e4a: 66 90 xchg %ax,%ax <== NOT EXECUTED executing->Wait.return_argument = event_out; _ISR_Enable( level ); if ( ticks ) { _Watchdog_Initialize( 109e4c: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 109e4f: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 109e56: c7 43 64 f4 9f 10 00 movl $0x109ff4,0x64(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 109e5d: 89 43 68 mov %eax,0x68(%ebx) <== NOT EXECUTED * the heap 109e60: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 109e67: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 109e6a: 89 53 54 mov %edx,0x54(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 109e6d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109e70: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 109e73: 50 push %eax <== NOT EXECUTED 109e74: 68 9c f8 11 00 push $0x11f89c <== NOT EXECUTED 109e79: e8 de 33 00 00 call 10d25c <_Watchdog_Insert> <== NOT EXECUTED 109e7e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109e81: e9 46 ff ff ff jmp 109dcc <_Event_Seize+0x7c> <== NOT EXECUTED 00109edc <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 109edc: 55 push %ebp <== NOT EXECUTED 109edd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109edf: 57 push %edi <== NOT EXECUTED 109ee0: 56 push %esi <== NOT EXECUTED 109ee1: 53 push %ebx <== NOT EXECUTED 109ee2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109ee5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 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 ]; 109ee8: 8b b3 f4 00 00 00 mov 0xf4(%ebx),%esi <== NOT EXECUTED option_set = (rtems_option) the_thread->Wait.option; 109eee: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 109ef1: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED _ISR_Disable( level ); 109ef4: 9c pushf <== NOT EXECUTED 109ef5: fa cli <== NOT EXECUTED 109ef6: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED pending_events = api->pending_events; 109ef9: 8b 0e mov (%esi),%ecx <== NOT EXECUTED event_condition = (rtems_event_set) the_thread->Wait.count; 109efb: 8b 53 24 mov 0x24(%ebx),%edx <== NOT EXECUTED seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 109efe: 89 d7 mov %edx,%edi <== NOT EXECUTED 109f00: 21 cf and %ecx,%edi <== NOT EXECUTED 109f02: 74 70 je 109f74 <_Event_Surrender+0x98> <== NOT EXECUTED /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && 109f04: a1 58 f8 11 00 mov 0x11f858,%eax <== NOT EXECUTED 109f09: 85 c0 test %eax,%eax <== NOT EXECUTED 109f0b: 74 0c je 109f19 <_Event_Surrender+0x3d> <== NOT EXECUTED 109f0d: 3b 1d 7c f8 11 00 cmp 0x11f87c,%ebx <== NOT EXECUTED 109f13: 0f 84 93 00 00 00 je 109fac <_Event_Surrender+0xd0> <== NOT EXECUTED } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 109f19: f6 43 11 01 testb $0x1,0x11(%ebx) <== NOT EXECUTED 109f1d: 75 0d jne 109f2c <_Event_Surrender+0x50> <== NOT EXECUTED _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 109f1f: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 109f22: 9d popf <== NOT EXECUTED } 109f23: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109f26: 5b pop %ebx <== NOT EXECUTED 109f27: 5e pop %esi <== NOT EXECUTED 109f28: 5f pop %edi <== NOT EXECUTED 109f29: c9 leave <== NOT EXECUTED 109f2a: c3 ret <== NOT EXECUTED 109f2b: 90 nop <== NOT EXECUTED /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { if ( seized_events == event_condition || _Options_Is_any( option_set ) ) { 109f2c: 39 fa cmp %edi,%edx <== NOT EXECUTED 109f2e: 74 06 je 109f36 <_Event_Surrender+0x5a> <== NOT EXECUTED 109f30: f6 45 f0 02 testb $0x2,-0x10(%ebp) <== NOT EXECUTED 109f34: 74 e9 je 109f1f <_Event_Surrender+0x43> <== NOT EXECUTED api->pending_events = _Event_sets_Clear( pending_events, seized_events ); 109f36: 89 f8 mov %edi,%eax <== NOT EXECUTED 109f38: f7 d0 not %eax <== NOT EXECUTED 109f3a: 21 c8 and %ecx,%eax <== NOT EXECUTED 109f3c: 89 06 mov %eax,(%esi) <== NOT EXECUTED the_thread->Wait.count = 0; 109f3e: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109f45: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 109f48: 89 38 mov %edi,(%eax) <== NOT EXECUTED _ISR_Flash( level ); 109f4a: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 109f4d: 9d popf <== NOT EXECUTED 109f4e: fa cli <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 109f4f: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 109f53: 74 2b je 109f80 <_Event_Surrender+0xa4> <== NOT EXECUTED _ISR_Enable( level ); 109f55: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 109f58: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 109f59: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109f5c: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 109f61: 53 push %ebx <== NOT EXECUTED 109f62: e8 3d 20 00 00 call 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 109f67: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return; } } _ISR_Enable( level ); } 109f6a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109f6d: 5b pop %ebx <== NOT EXECUTED 109f6e: 5e pop %esi <== NOT EXECUTED 109f6f: 5f pop %edi <== NOT EXECUTED 109f70: c9 leave <== NOT EXECUTED 109f71: c3 ret <== NOT EXECUTED 109f72: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { _ISR_Enable( level ); 109f74: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 109f77: 9d popf <== NOT EXECUTED } return; } } _ISR_Enable( level ); } 109f78: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109f7b: 5b pop %ebx <== NOT EXECUTED 109f7c: 5e pop %esi <== NOT EXECUTED 109f7d: 5f pop %edi <== NOT EXECUTED 109f7e: c9 leave <== NOT EXECUTED 109f7f: c3 ret <== NOT EXECUTED * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 109f80: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 109f87: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 109f8a: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 109f8b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109f8e: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 109f91: 50 push %eax <== NOT EXECUTED 109f92: e8 f5 33 00 00 call 10d38c <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 109f97: 58 pop %eax <== NOT EXECUTED 109f98: 5a pop %edx <== NOT EXECUTED 109f99: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 109f9e: 53 push %ebx <== NOT EXECUTED 109f9f: e8 00 20 00 00 call 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 109fa4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109fa7: e9 77 ff ff ff jmp 109f23 <_Event_Surrender+0x47> <== NOT EXECUTED /* * If we are in an ISR and sending to the current thread, then * we have a critical section issue to deal with. */ if ( _ISR_Is_in_progress() && 109fac: a1 80 01 12 00 mov 0x120180,%eax <== NOT EXECUTED 109fb1: 48 dec %eax <== NOT EXECUTED 109fb2: 74 0e je 109fc2 <_Event_Surrender+0xe6> <== NOT EXECUTED 109fb4: a1 80 01 12 00 mov 0x120180,%eax <== NOT EXECUTED 109fb9: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109fbc: 0f 85 57 ff ff ff jne 109f19 <_Event_Surrender+0x3d> <== NOT EXECUTED _Thread_Is_executing( the_thread ) && ((_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) || (_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT)) ) { if ( seized_events == event_condition || _Options_Is_any(option_set) ) { 109fc2: 39 fa cmp %edi,%edx <== NOT EXECUTED 109fc4: 74 06 je 109fcc <_Event_Surrender+0xf0> <== NOT EXECUTED 109fc6: f6 45 f0 02 testb $0x2,-0x10(%ebp) <== NOT EXECUTED 109fca: 74 1e je 109fea <_Event_Surrender+0x10e> <== NOT EXECUTED api->pending_events = _Event_sets_Clear( pending_events,seized_events ); 109fcc: 89 f8 mov %edi,%eax <== NOT EXECUTED 109fce: f7 d0 not %eax <== NOT EXECUTED 109fd0: 21 c8 and %ecx,%eax <== NOT EXECUTED 109fd2: 89 06 mov %eax,(%esi) <== NOT EXECUTED the_thread->Wait.count = 0; 109fd4: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) <== NOT EXECUTED *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109fdb: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 109fde: 89 38 mov %edi,(%eax) <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 109fe0: c7 05 80 01 12 00 03 movl $0x3,0x120180 <== NOT EXECUTED 109fe7: 00 00 00 <== NOT EXECUTED } _ISR_Enable( level ); 109fea: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 109fed: 9d popf <== NOT EXECUTED 109fee: e9 30 ff ff ff jmp 109f23 <_Event_Surrender+0x47> <== NOT EXECUTED 00109ff4 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 109ff4: 55 push %ebp <== NOT EXECUTED 109ff5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109ff7: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 109ffa: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 109ffd: 50 push %eax <== NOT EXECUTED 109ffe: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a001: e8 6a 23 00 00 call 10c370 <_Thread_Get> <== NOT EXECUTED 10a006: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 10a008: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a00b: 8b 4d fc mov -0x4(%ebp),%ecx <== NOT EXECUTED 10a00e: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a010: 75 3e jne 10a050 <_Event_Timeout+0x5c> <== NOT EXECUTED * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ _ISR_Disable( level ); 10a012: 9c pushf <== NOT EXECUTED 10a013: fa cli <== NOT EXECUTED 10a014: 59 pop %ecx <== NOT EXECUTED if ( !the_thread->Wait.count ) { /* verify thread is waiting */ 10a015: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED 10a018: 85 c0 test %eax,%eax <== NOT EXECUTED 10a01a: 74 38 je 10a054 <_Event_Timeout+0x60> <== NOT EXECUTED _Thread_Unnest_dispatch(); _ISR_Enable( level ); return; } the_thread->Wait.count = 0; 10a01c: c7 42 24 00 00 00 00 movl $0x0,0x24(%edx) <== NOT EXECUTED if ( _Thread_Is_executing( the_thread ) ) { 10a023: 3b 15 7c f8 11 00 cmp 0x11f87c,%edx <== NOT EXECUTED 10a029: 74 39 je 10a064 <_Event_Timeout+0x70> <== NOT EXECUTED (sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; } } the_thread->Wait.return_code = RTEMS_TIMEOUT; 10a02b: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) <== NOT EXECUTED _ISR_Enable( level ); 10a032: 51 push %ecx <== NOT EXECUTED 10a033: 9d popf <== NOT EXECUTED 10a034: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a037: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10a03c: 52 push %edx <== NOT EXECUTED 10a03d: e8 62 1f 00 00 call 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 10a042: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10a047: 48 dec %eax <== NOT EXECUTED 10a048: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED 10a04d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10a050: c9 leave <== NOT EXECUTED 10a051: c3 ret <== NOT EXECUTED 10a052: 66 90 xchg %ax,%ax <== NOT EXECUTED 10a054: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10a059: 48 dec %eax <== NOT EXECUTED 10a05a: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED _ISR_Disable( level ); if ( !the_thread->Wait.count ) { /* verify thread is waiting */ _Thread_Unnest_dispatch(); _ISR_Enable( level ); 10a05f: 51 push %ecx <== NOT EXECUTED 10a060: 9d popf <== NOT EXECUTED case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10a061: c9 leave <== NOT EXECUTED 10a062: c3 ret <== NOT EXECUTED 10a063: 90 nop <== NOT EXECUTED return; } the_thread->Wait.count = 0; if ( _Thread_Is_executing( the_thread ) ) { Thread_blocking_operation_States sync = _Event_Sync_state; 10a064: a1 80 01 12 00 mov 0x120180,%eax <== NOT EXECUTED if ( (sync == THREAD_BLOCKING_OPERATION_SYNCHRONIZED) || 10a069: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10a06c: 77 bd ja 10a02b <_Event_Timeout+0x37> <== NOT EXECUTED (sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10a06e: c7 05 80 01 12 00 02 movl $0x2,0x120180 <== NOT EXECUTED 10a075: 00 00 00 <== NOT EXECUTED 10a078: eb b1 jmp 10a02b <_Event_Timeout+0x37> <== NOT EXECUTED 0010aa24 <_Extension_Manager_initialization>: */ void _Extension_Manager_initialization( uint32_t maximum_extensions ) { 10aa24: 55 push %ebp <== NOT EXECUTED 10aa25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa27: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10aa2a: 6a 04 push $0x4 <== NOT EXECUTED 10aa2c: 6a 00 push $0x0 <== NOT EXECUTED 10aa2e: 6a 44 push $0x44 <== NOT EXECUTED 10aa30: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10aa33: 6a 09 push $0x9 <== NOT EXECUTED 10aa35: 6a 02 push $0x2 <== NOT EXECUTED 10aa37: 68 e0 01 12 00 push $0x1201e0 <== NOT EXECUTED 10aa3c: e8 2b 11 00 00 call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10aa41: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , false, /* true if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10aa44: c9 leave <== NOT EXECUTED 10aa45: c3 ret <== NOT EXECUTED 0010f93c <_Heap_Allocate>: void *_Heap_Allocate( Heap_Control *the_heap, size_t size ) { 10f93c: 55 push %ebp <== NOT EXECUTED 10f93d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f93f: 57 push %edi <== NOT EXECUTED 10f940: 56 push %esi <== NOT EXECUTED 10f941: 53 push %ebx <== NOT EXECUTED 10f942: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10f945: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED Heap_Block *the_block; void *ptr = NULL; Heap_Statistics *const stats = &the_heap->stats; Heap_Block *const tail = _Heap_Tail(the_heap); the_size = 10f948: ff 77 14 pushl 0x14(%edi) <== NOT EXECUTED 10f94b: ff 77 10 pushl 0x10(%edi) <== NOT EXECUTED 10f94e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10f951: e8 72 bb ff ff call 10b4c8 <_Heap_Calc_block_size> <== NOT EXECUTED _Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size); if(the_size == 0) 10f956: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f959: 85 c0 test %eax,%eax <== NOT EXECUTED 10f95b: 74 3b je 10f998 <_Heap_Allocate+0x5c> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( 10f95d: 8b 5f 08 mov 0x8(%edi),%ebx <== NOT EXECUTED return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 10f960: 39 df cmp %ebx,%edi <== NOT EXECUTED 10f962: 74 34 je 10f998 <_Heap_Allocate+0x5c> <== NOT EXECUTED /* 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) { 10f964: 3b 43 04 cmp 0x4(%ebx),%eax <== NOT EXECUTED 10f967: 76 5c jbe 10f9c5 <_Heap_Allocate+0x89> <== NOT EXECUTED stats->allocs += 1; stats->searches += search_count + 1; _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; 10f969: 31 f6 xor %esi,%esi <== NOT EXECUTED 10f96b: eb 08 jmp 10f975 <_Heap_Allocate+0x39> <== NOT EXECUTED 10f96d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* 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) { 10f970: 3b 43 04 cmp 0x4(%ebx),%eax <== NOT EXECUTED 10f973: 76 2f jbe 10f9a4 <_Heap_Allocate+0x68> <== NOT EXECUTED 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) 10f975: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10f978: 46 inc %esi <== NOT EXECUTED if(the_size == 0) return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 10f979: 39 df cmp %ebx,%edi <== NOT EXECUTED 10f97b: 75 f3 jne 10f970 <_Heap_Allocate+0x34> <== NOT EXECUTED 10f97d: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED 10f980: 31 d2 xor %edx,%edx <== NOT EXECUTED _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 10f982: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10f985: 39 47 44 cmp %eax,0x44(%edi) <== NOT EXECUTED 10f988: 73 03 jae 10f98d <_Heap_Allocate+0x51> <== NOT EXECUTED stats->max_search = search_count; 10f98a: 89 47 44 mov %eax,0x44(%edi) <== NOT EXECUTED return ptr; } 10f98d: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f98f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f992: 5b pop %ebx <== NOT EXECUTED 10f993: 5e pop %esi <== NOT EXECUTED 10f994: 5f pop %edi <== NOT EXECUTED 10f995: c9 leave <== NOT EXECUTED 10f996: c3 ret <== NOT EXECUTED 10f997: 90 nop <== NOT EXECUTED break; } } if(stats->max_search < search_count) stats->max_search = search_count; 10f998: 31 d2 xor %edx,%edx <== NOT EXECUTED return ptr; } 10f99a: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f99c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f99f: 5b pop %ebx <== NOT EXECUTED 10f9a0: 5e pop %esi <== NOT EXECUTED 10f9a1: 5f pop %edi <== NOT EXECUTED 10f9a2: c9 leave <== NOT EXECUTED 10f9a3: c3 ret <== NOT EXECUTED /* 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) { 10f9a4: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED (void)_Heap_Block_allocate(the_heap, the_block, the_size ); 10f9a7: 52 push %edx <== NOT EXECUTED 10f9a8: 50 push %eax <== NOT EXECUTED 10f9a9: 53 push %ebx <== NOT EXECUTED 10f9aa: 57 push %edi <== NOT EXECUTED 10f9ab: e8 4c bb ff ff call 10b4fc <_Heap_Block_allocate> <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 10f9b0: 8d 53 08 lea 0x8(%ebx),%edx <== NOT EXECUTED ptr = _Heap_User_area(the_block); stats->allocs += 1; 10f9b3: ff 47 48 incl 0x48(%edi) <== NOT EXECUTED stats->searches += search_count + 1; 10f9b6: 8b 47 4c mov 0x4c(%edi),%eax <== NOT EXECUTED 10f9b9: 8d 44 06 01 lea 0x1(%esi,%eax,1),%eax <== NOT EXECUTED 10f9bd: 89 47 4c mov %eax,0x4c(%edi) <== NOT EXECUTED 10f9c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f9c3: eb bd jmp 10f982 <_Heap_Allocate+0x46> <== NOT EXECUTED /* 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) { 10f9c5: 31 f6 xor %esi,%esi <== NOT EXECUTED 10f9c7: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED 10f9ce: eb d7 jmp 10f9a7 <_Heap_Allocate+0x6b> <== NOT EXECUTED 0010ccc0 <_Heap_Allocate_aligned>: void *_Heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 10ccc0: 55 push %ebp <== NOT EXECUTED 10ccc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ccc3: 57 push %edi <== NOT EXECUTED 10ccc4: 56 push %esi <== NOT EXECUTED 10ccc5: 53 push %ebx <== NOT EXECUTED 10ccc6: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 10ccc9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED uint32_t search_count; Heap_Block *the_block; void *user_ptr = NULL; uint32_t const page_size = the_heap->page_size; 10cccc: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10cccf: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 10ccd2: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED Heap_Statistics *const stats = &the_heap->stats; Heap_Block *const tail = _Heap_Tail(the_heap); uint32_t const end_to_user_offs = size - HEAP_BLOCK_HEADER_OFFSET; 10ccd5: 8d 48 fc lea -0x4(%eax),%ecx <== NOT EXECUTED 10ccd8: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED uint32_t const the_size = _Heap_Calc_block_size(size, page_size, the_heap->min_block_size); 10ccdb: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10ccde: ff 77 14 pushl 0x14(%edi) <== NOT EXECUTED 10cce1: 52 push %edx <== NOT EXECUTED 10cce2: 50 push %eax <== NOT EXECUTED 10cce3: e8 8c 04 00 00 call 10d174 <_Heap_Calc_block_size> <== NOT EXECUTED 10cce8: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED if(the_size == 0) 10cceb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ccee: 85 c0 test %eax,%eax <== NOT EXECUTED 10ccf0: 0f 84 1a 01 00 00 je 10ce10 <_Heap_Allocate_aligned+0x150> <== NOT EXECUTED return NULL; if(alignment == 0) 10ccf6: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10ccf9: 85 c0 test %eax,%eax <== NOT EXECUTED 10ccfb: 0f 84 03 01 00 00 je 10ce04 <_Heap_Allocate_aligned+0x144> <== NOT EXECUTED ) { return ( the_thread == _Thread_Heir ); } /** 10cd01: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cd04: 8b 48 08 mov 0x8(%eax),%ecx <== NOT EXECUTED alignment = CPU_ALIGNMENT; /* Find large enough free block that satisfies the alignment requirements. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 10cd07: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10cd09: 0f 84 01 01 00 00 je 10ce10 <_Heap_Allocate_aligned+0x150> <== NOT EXECUTED 10cd0f: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED 10cd16: eb 17 jmp 10cd2f <_Heap_Allocate_aligned+0x6f> <== NOT EXECUTED 'aligned_user_addr' to be outside of [0,page_size) range. If we do, we will need to store this distance somewhere to be able to resurrect the block address from the user pointer. (Having the distance within [0,page_size) range allows resurrection by aligning user pointer down to the nearest 'page_size' boundary.) */ if(aligned_user_addr - user_addr >= page_size) { 10cd18: 89 f2 mov %esi,%edx <== NOT EXECUTED aligned_user_addr = 0; } } } if(aligned_user_addr) { 10cd1a: 85 ff test %edi,%edi <== NOT EXECUTED 10cd1c: 75 7a jne 10cd98 <_Heap_Allocate_aligned+0xd8> <== NOT EXECUTED 10cd1e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* Find large enough free block that satisfies the alignment requirements. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; the_block = the_block->next, ++search_count) 10cd20: 8b 49 08 mov 0x8(%ecx),%ecx <== NOT EXECUTED 10cd23: ff 45 f0 incl -0x10(%ebp) <== NOT EXECUTED alignment = CPU_ALIGNMENT; /* Find large enough free block that satisfies the alignment requirements. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 10cd26: 39 4d 08 cmp %ecx,0x8(%ebp) <== NOT EXECUTED 10cd29: 0f 84 ed 00 00 00 je 10ce1c <_Heap_Allocate_aligned+0x15c> <== NOT EXECUTED 10cd2f: 8b 59 04 mov 0x4(%ecx),%ebx <== NOT EXECUTED 10cd32: 83 e3 fe and $0xfffffffe,%ebx <== NOT EXECUTED uint32_t const block_size = _Heap_Block_size(the_block); /* As we always coalesce free blocks, prev block must have been used. */ _HAssert(_Heap_Is_prev_used(the_block)); if(block_size >= the_size) { /* the_block is large enough. */ 10cd35: 39 5d e4 cmp %ebx,-0x1c(%ebp) <== NOT EXECUTED 10cd38: 77 e6 ja 10cd20 <_Heap_Allocate_aligned+0x60> <== NOT EXECUTED _H_uptr_t user_addr; _H_uptr_t aligned_user_addr; _H_uptr_t const user_area = _H_p2u(_Heap_User_area(the_block)); 10cd3a: 8d 71 08 lea 0x8(%ecx),%esi <== NOT EXECUTED /* Calculate 'aligned_user_addr' that will become the user pointer we return. It should be at least 'end_to_user_offs' bytes less than the the 'block_end' and should be aligned on 'alignment' boundary. Calculations are from the 'block_end' as we are going to split free block so that the upper part of the block becomes used block. */ _H_uptr_t const block_end = _H_p2u(the_block) + block_size; 10cd3d: 8d 14 19 lea (%ecx,%ebx,1),%edx <== NOT EXECUTED 10cd40: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED aligned_user_addr = block_end - end_to_user_offs; 10cd43: 89 d7 mov %edx,%edi <== NOT EXECUTED 10cd45: 2b 7d e0 sub -0x20(%ebp),%edi <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization( void ) { _Thread_Dispatch_disable_level = 1; } 10cd48: 89 f8 mov %edi,%eax <== NOT EXECUTED 10cd4a: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cd4c: f7 75 10 divl 0x10(%ebp) <== NOT EXECUTED 10cd4f: 29 d7 sub %edx,%edi <== NOT EXECUTED 10cd51: 89 f8 mov %edi,%eax <== NOT EXECUTED 10cd53: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cd55: f7 75 dc divl -0x24(%ebp) <== NOT EXECUTED 10cd58: 89 f8 mov %edi,%eax <== NOT EXECUTED 10cd5a: 29 d0 sub %edx,%eax <== NOT EXECUTED 10cd5c: 89 c2 mov %eax,%edx <== NOT EXECUTED only at 'page_size' aligned addresses */ user_addr = aligned_user_addr; _Heap_Align_down_uptr(&user_addr, page_size); /* Make sure 'user_addr' calculated didn't run out of 'the_block'. */ if(user_addr >= user_area) { 10cd5e: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10cd60: 77 be ja 10cd20 <_Heap_Allocate_aligned+0x60> <== NOT EXECUTED /* The block seems to be acceptable. Check if the remainder of 'the_block' is less than 'min_block_size' so that 'the_block' won't actually be split at the address we assume. */ if(user_addr - user_area < the_heap->min_block_size) { 10cd62: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cd65: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10cd68: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 10cd6b: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cd6d: 29 f0 sub %esi,%eax <== NOT EXECUTED 10cd6f: 3b 45 ec cmp -0x14(%ebp),%eax <== NOT EXECUTED 10cd72: 73 a6 jae 10cd1a <_Heap_Allocate_aligned+0x5a> <== NOT EXECUTED 'aligned_user_addr' to be outside of [0,page_size) range. If we do, we will need to store this distance somewhere to be able to resurrect the block address from the user pointer. (Having the distance within [0,page_size) range allows resurrection by aligning user pointer down to the nearest 'page_size' boundary.) */ if(aligned_user_addr - user_addr >= page_size) { 10cd74: 89 f8 mov %edi,%eax <== NOT EXECUTED 10cd76: 29 f0 sub %esi,%eax <== NOT EXECUTED 10cd78: 39 45 dc cmp %eax,-0x24(%ebp) <== NOT EXECUTED 10cd7b: 77 9b ja 10cd18 <_Heap_Allocate_aligned+0x58> <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); } /** 10cd7d: 89 f0 mov %esi,%eax <== NOT EXECUTED 10cd7f: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cd81: f7 75 10 divl 0x10(%ebp) <== NOT EXECUTED * This function returns TRUE if dispatching is disabled, and FALSE 10cd84: 85 d2 test %edx,%edx <== NOT EXECUTED 10cd86: 75 6c jne 10cdf4 <_Heap_Allocate_aligned+0x134> <== NOT EXECUTED 10cd88: 89 f0 mov %esi,%eax <== NOT EXECUTED /* The user pointer will be too far from 'user_addr'. See if we can make 'aligned_user_addr' to be close enough to the 'user_addr'. */ aligned_user_addr = user_addr; _Heap_Align_up_uptr(&aligned_user_addr, alignment); if(aligned_user_addr - user_addr >= page_size) { 10cd8a: 39 55 dc cmp %edx,-0x24(%ebp) <== NOT EXECUTED 10cd8d: 76 91 jbe 10cd20 <_Heap_Allocate_aligned+0x60> <== NOT EXECUTED 10cd8f: 89 f2 mov %esi,%edx <== NOT EXECUTED 10cd91: 89 c7 mov %eax,%edi <== NOT EXECUTED aligned_user_addr = 0; } } } if(aligned_user_addr) { 10cd93: 85 ff test %edi,%edi <== NOT EXECUTED 10cd95: 74 89 je 10cd20 <_Heap_Allocate_aligned+0x60> <== NOT EXECUTED 10cd97: 90 nop <== NOT EXECUTED /* The block is indeed acceptable: calculate the size of the block to be allocated and perform allocation. */ uint32_t const alloc_size = block_end - user_addr + HEAP_BLOCK_USER_OFFSET; 10cd98: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 10cd9b: 83 c6 08 add $0x8,%esi <== NOT EXECUTED 10cd9e: 29 d6 sub %edx,%esi <== NOT EXECUTED Heap_Block *the_block, uint32_t alloc_size) { Heap_Statistics *const stats = &the_heap->stats; uint32_t const block_size = _Heap_Block_size(the_block); uint32_t const the_rest = block_size - alloc_size; 10cda0: 89 da mov %ebx,%edx <== NOT EXECUTED 10cda2: 29 f2 sub %esi,%edx <== NOT EXECUTED _HAssert(_Heap_Is_aligned(block_size, the_heap->page_size)); _HAssert(_Heap_Is_aligned(alloc_size, the_heap->page_size)); _HAssert(alloc_size <= block_size); _HAssert(_Heap_Is_prev_used(the_block)); if(the_rest >= the_heap->min_block_size) { 10cda4: 3b 55 ec cmp -0x14(%ebp),%edx <== NOT EXECUTED 10cda7: 0f 82 87 00 00 00 jb 10ce34 <_Heap_Allocate_aligned+0x174> <== NOT EXECUTED /* Split the block so that lower part is still free, and upper part becomes used. */ the_block->size = the_rest | HEAP_PREV_USED; 10cdad: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cdaf: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10cdb2: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED Context_Control *context_p = &context_area; if ( _System_state_Is_up(_System_state_Get ()) ) context_p = &_Thread_Executing->Registers; _Context_Switch( context_p, &_Thread_BSP_context ); 10cdb5: 8d 04 11 lea (%ecx,%edx,1),%eax <== NOT EXECUTED /** @brief _Thread_Is_proxy_blocking * * status which indicates that a proxy is blocking, and FALSE otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking ( uint32_t code 10cdb8: 89 c1 mov %eax,%ecx <== NOT EXECUTED the_block = _Heap_Block_at(the_block, the_rest); the_block->prev_size = the_rest; 10cdba: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_block->size = alloc_size; 10cdbc: 89 70 04 mov %esi,0x4(%eax) <== NOT EXECUTED _Heap_Block_remove(the_block); alloc_size = block_size; stats->free_blocks -= 1; } /* Mark the block as used (in the next block). */ _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED; 10cdbf: 83 4c 31 04 01 orl $0x1,0x4(%ecx,%esi,1) <== NOT EXECUTED /* Update statistics */ stats->free_size -= alloc_size; 10cdc4: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10cdc7: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10cdca: 29 f0 sub %esi,%eax <== NOT EXECUTED 10cdcc: 89 42 30 mov %eax,0x30(%edx) <== NOT EXECUTED if(stats->min_free_size > stats->free_size) 10cdcf: 3b 42 34 cmp 0x34(%edx),%eax <== NOT EXECUTED 10cdd2: 73 03 jae 10cdd7 <_Heap_Allocate_aligned+0x117> <== NOT EXECUTED stats->min_free_size = stats->free_size; 10cdd4: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED stats->used_blocks += 1; 10cdd7: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10cdda: ff 41 40 incl 0x40(%ecx) <== NOT EXECUTED _HAssert(_Heap_Is_aligned_ptr((void*)aligned_user_addr, alignment)); the_block = block_allocate(the_heap, the_block, alloc_size); stats->searches += search_count + 1; 10cddd: 8b 41 4c mov 0x4c(%ecx),%eax <== NOT EXECUTED 10cde0: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10cde3: 8d 44 02 01 lea 0x1(%edx,%eax,1),%eax <== NOT EXECUTED 10cde7: 89 41 4c mov %eax,0x4c(%ecx) <== NOT EXECUTED stats->allocs += 1; 10cdea: ff 41 48 incl 0x48(%ecx) <== NOT EXECUTED check_result(the_heap, the_block, user_addr, aligned_user_addr, size); user_ptr = (void*)aligned_user_addr; 10cded: 89 f8 mov %edi,%eax <== NOT EXECUTED 10cdef: eb 2d jmp 10ce1e <_Heap_Allocate_aligned+0x15e> <== NOT EXECUTED 10cdf1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { return ( _Thread_Dispatch_disable_level == 0 ); } /** * This function returns TRUE if dispatching is disabled, and FALSE 10cdf4: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10cdf7: 8d 04 3e lea (%esi,%edi,1),%eax <== NOT EXECUTED 10cdfa: 29 d0 sub %edx,%eax <== NOT EXECUTED 10cdfc: 89 c2 mov %eax,%edx <== NOT EXECUTED 10cdfe: 29 f2 sub %esi,%edx <== NOT EXECUTED 10ce00: eb 88 jmp 10cd8a <_Heap_Allocate_aligned+0xca> <== NOT EXECUTED 10ce02: 66 90 xchg %ax,%ax <== NOT EXECUTED _Heap_Calc_block_size(size, page_size, the_heap->min_block_size); if(the_size == 0) return NULL; if(alignment == 0) 10ce04: c7 45 10 04 00 00 00 movl $0x4,0x10(%ebp) <== NOT EXECUTED 10ce0b: e9 f1 fe ff ff jmp 10cd01 <_Heap_Allocate_aligned+0x41> <== NOT EXECUTED } } } if(stats->max_search < search_count) stats->max_search = search_count; 10ce10: 31 c0 xor %eax,%eax <== NOT EXECUTED return user_ptr; } 10ce12: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ce15: 5b pop %ebx <== NOT EXECUTED 10ce16: 5e pop %esi <== NOT EXECUTED 10ce17: 5f pop %edi <== NOT EXECUTED 10ce18: c9 leave <== NOT EXECUTED 10ce19: c3 ret <== NOT EXECUTED 10ce1a: 66 90 xchg %ax,%ax <== NOT EXECUTED alignment = CPU_ALIGNMENT; /* Find large enough free block that satisfies the alignment requirements. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 10ce1c: 31 c0 xor %eax,%eax <== NOT EXECUTED } } } } if(stats->max_search < search_count) 10ce1e: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10ce21: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10ce24: 39 4f 44 cmp %ecx,0x44(%edi) <== NOT EXECUTED 10ce27: 73 e9 jae 10ce12 <_Heap_Allocate_aligned+0x152> <== NOT EXECUTED stats->max_search = search_count; 10ce29: 89 4f 44 mov %ecx,0x44(%edi) <== NOT EXECUTED return user_ptr; } 10ce2c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ce2f: 5b pop %ebx <== NOT EXECUTED 10ce30: 5e pop %esi <== NOT EXECUTED 10ce31: 5f pop %edi <== NOT EXECUTED 10ce32: c9 leave <== NOT EXECUTED 10ce33: c3 ret <== NOT EXECUTED * This routine resets the current context of the calling thread * to that of its initial state. */ RTEMS_INLINE_ROUTINE void _Thread_Restart_self( void ) { 10ce34: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) 10ce37: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED if ( _Thread_Executing->fp_context != NULL ) 10ce3a: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED _Context_Restore_fp( &_Thread_Executing->fp_context ); 10ce3d: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED /* Don't split the block as remainder is either zero or too small to be used as a separate free block. Change 'alloc_size' to the size of the block and remove the block from the list of free blocks. */ _Heap_Block_remove(the_block); alloc_size = block_size; stats->free_blocks -= 1; 10ce40: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ce43: ff 48 38 decl 0x38(%eax) <== NOT EXECUTED 10ce46: 89 de mov %ebx,%esi <== NOT EXECUTED 10ce48: e9 72 ff ff ff jmp 10cdbf <_Heap_Allocate_aligned+0xff> <== NOT EXECUTED 0010b4fc <_Heap_Block_allocate>: uint32_t _Heap_Block_allocate( Heap_Control* the_heap, Heap_Block* the_block, uint32_t alloc_size ) { 10b4fc: 55 push %ebp <== NOT EXECUTED 10b4fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4ff: 57 push %edi <== NOT EXECUTED 10b500: 56 push %esi <== NOT EXECUTED 10b501: 53 push %ebx <== NOT EXECUTED 10b502: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10b505: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10b508: 8b 4e 04 mov 0x4(%esi),%ecx <== NOT EXECUTED 10b50b: 83 e1 fe and $0xfffffffe,%ecx <== NOT EXECUTED Heap_Statistics *const stats = &the_heap->stats; uint32_t const block_size = _Heap_Block_size(the_block); uint32_t const the_rest = block_size - alloc_size; 10b50e: 89 cb mov %ecx,%ebx <== NOT EXECUTED 10b510: 29 fb sub %edi,%ebx <== NOT EXECUTED _HAssert(_Heap_Is_aligned(block_size, the_heap->page_size)); _HAssert(_Heap_Is_aligned(alloc_size, the_heap->page_size)); _HAssert(alloc_size <= block_size); _HAssert(_Heap_Is_prev_used(the_block)); if(the_rest >= the_heap->min_block_size) { 10b512: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b515: 3b 58 14 cmp 0x14(%eax),%ebx <== NOT EXECUTED 10b518: 72 4a jb 10b564 <_Heap_Block_allocate+0x68> <== NOT EXECUTED 10b51a: 8d 14 3e lea (%esi,%edi,1),%edx <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ 10b51d: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED bool _Protected_heap_Get_block_size( 10b520: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size 10b523: 89 4a 08 mov %ecx,0x8(%edx) <== NOT EXECUTED ); 10b526: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 10b529: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED 10b52c: 89 51 0c mov %edx,0xc(%ecx) <== NOT EXECUTED becomes used. This is slightly less optimal than leaving lower part free as it requires replacing block in the free blocks list, but it makes it possible to reuse this code in the _Heap_Resize_block(). */ Heap_Block *next_block = _Heap_Block_at(the_block, alloc_size); _Heap_Block_replace(the_block, next_block); the_block->size = alloc_size | HEAP_PREV_USED; 10b52f: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b531: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10b534: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED next_block->size = the_rest | HEAP_PREV_USED; 10b537: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b539: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10b53c: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED _Heap_Block_at(next_block, the_rest)->prev_size = the_rest; 10b53f: 89 1c 1a mov %ebx,(%edx,%ebx,1) <== NOT EXECUTED alloc_size = block_size; _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED; stats->free_blocks -= 1; } /* Update statistics */ stats->free_size -= alloc_size; 10b542: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b545: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10b548: 29 f8 sub %edi,%eax <== NOT EXECUTED 10b54a: 89 42 30 mov %eax,0x30(%edx) <== NOT EXECUTED if(stats->min_free_size > stats->free_size) 10b54d: 3b 42 34 cmp 0x34(%edx),%eax <== NOT EXECUTED 10b550: 73 03 jae 10b555 <_Heap_Block_allocate+0x59> <== NOT EXECUTED stats->min_free_size = stats->free_size; 10b552: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED stats->used_blocks += 1; 10b555: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b558: ff 40 40 incl 0x40(%eax) <== NOT EXECUTED return alloc_size; } 10b55b: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b55d: 5b pop %ebx <== NOT EXECUTED 10b55e: 5e pop %esi <== NOT EXECUTED 10b55f: 5f pop %edi <== NOT EXECUTED 10b560: c9 leave <== NOT EXECUTED 10b561: c3 ret <== NOT EXECUTED 10b562: 66 90 xchg %ax,%ax <== NOT EXECUTED * Any other value of @a alignment is taken "as is", i.e., even odd * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon 10b564: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes 10b567: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED * @param[in] alignment the required alignment 10b56a: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10b56d: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED /* Don't split the block as remainder is either zero or too small to be used as a separate free block. Change 'alloc_size' to the size of the block and remove the block from the list of free blocks. */ _Heap_Block_remove(the_block); alloc_size = block_size; _Heap_Block_at(the_block, alloc_size)->size |= HEAP_PREV_USED; 10b570: 83 4c 0e 04 01 orl $0x1,0x4(%esi,%ecx,1) <== NOT EXECUTED stats->free_blocks -= 1; 10b575: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b578: ff 4a 38 decl 0x38(%edx) <== NOT EXECUTED 10b57b: 89 cf mov %ecx,%edi <== NOT EXECUTED 10b57d: eb c3 jmp 10b542 <_Heap_Block_allocate+0x46> <== NOT EXECUTED 0010b4c8 <_Heap_Calc_block_size>: */ size_t _Heap_Calc_block_size( size_t size, uint32_t page_size, uint32_t min_size) { 10b4c8: 55 push %ebp <== NOT EXECUTED 10b4c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4cb: 53 push %ebx <== NOT EXECUTED 10b4cc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b4cf: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD; 10b4d2: 8d 59 04 lea 0x4(%ecx),%ebx <== NOT EXECUTED * sizes. * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area * * @return true if successfully able to return information 10b4d5: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b4d7: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b4d9: f7 75 0c divl 0xc(%ebp) <== NOT EXECUTED */ 10b4dc: 85 d2 test %edx,%edx <== NOT EXECUTED 10b4de: 74 05 je 10b4e5 <_Heap_Calc_block_size+0x1d> <== NOT EXECUTED 10b4e0: 03 5d 0c add 0xc(%ebp),%ebx <== NOT EXECUTED 10b4e3: 29 d3 sub %edx,%ebx <== NOT EXECUTED 10b4e5: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b4e7: 3b 5d 10 cmp 0x10(%ebp),%ebx <== NOT EXECUTED 10b4ea: 73 03 jae 10b4ef <_Heap_Calc_block_size+0x27> <== NOT EXECUTED 10b4ec: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED _Heap_Align_up(&block_size, page_size); if (block_size < min_size) block_size = min_size; /* 'block_size' becomes <= 'size' if and only if overflow occured. */ return (block_size > size) ? block_size : 0; 10b4ef: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10b4f1: 72 02 jb 10b4f5 <_Heap_Calc_block_size+0x2d> <== NOT EXECUTED 10b4f3: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10b4f5: 5a pop %edx <== NOT EXECUTED 10b4f6: 5b pop %ebx <== NOT EXECUTED 10b4f7: c9 leave <== NOT EXECUTED 10b4f8: c3 ret <== NOT EXECUTED 00111ad4 <_Heap_Extend>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t *amount_extended ) { 111ad4: 55 push %ebp <== NOT EXECUTED 111ad5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111ad7: 56 push %esi <== NOT EXECUTED 111ad8: 53 push %ebx <== NOT EXECUTED 111ad9: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 111adc: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 111adf: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED * 5. non-contiguous higher address (NOT SUPPORTED) * * As noted, this code only supports (4). */ if ( starting_address >= the_heap->begin && /* case 3 */ 111ae2: 39 41 18 cmp %eax,0x18(%ecx) <== NOT EXECUTED 111ae5: 76 15 jbe 111afc <_Heap_Extend+0x28> <== NOT EXECUTED 111ae7: 8b 51 1c mov 0x1c(%ecx),%edx <== NOT EXECUTED starting_address < the_heap->end ) return HEAP_EXTEND_ERROR; if ( starting_address != the_heap->end ) 111aea: 39 d0 cmp %edx,%eax <== NOT EXECUTED 111aec: 74 22 je 111b10 <_Heap_Extend+0x3c> <== NOT EXECUTED 111aee: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED stats->frees -= 1; /* Don't count subsequent call as actual free() */ _Heap_Free( the_heap, _Heap_User_area( old_final ) ); return HEAP_EXTEND_SUCCESSFUL; } 111af3: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111af6: 5b pop %ebx <== NOT EXECUTED 111af7: 5e pop %esi <== NOT EXECUTED 111af8: c9 leave <== NOT EXECUTED 111af9: c3 ret <== NOT EXECUTED 111afa: 66 90 xchg %ax,%ax <== NOT EXECUTED * 5. non-contiguous higher address (NOT SUPPORTED) * * As noted, this code only supports (4). */ if ( starting_address >= the_heap->begin && /* case 3 */ 111afc: 8b 51 1c mov 0x1c(%ecx),%edx <== NOT EXECUTED 111aff: 39 d0 cmp %edx,%eax <== NOT EXECUTED 111b01: 73 e7 jae 111aea <_Heap_Extend+0x16> <== NOT EXECUTED 111b03: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED stats->frees -= 1; /* Don't count subsequent call as actual free() */ _Heap_Free( the_heap, _Heap_User_area( old_final ) ); return HEAP_EXTEND_SUCCESSFUL; } 111b08: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111b0b: 5b pop %ebx <== NOT EXECUTED 111b0c: 5e pop %esi <== NOT EXECUTED 111b0d: c9 leave <== NOT EXECUTED 111b0e: c3 ret <== NOT EXECUTED 111b0f: 90 nop <== NOT EXECUTED * Currently only case 4 should make it to this point. * The basic trick is to make the extend area look like a used * block and free it. */ old_final = the_heap->final; 111b10: 8b 59 24 mov 0x24(%ecx),%ebx <== NOT EXECUTED Context_Control *context_p = &context_area; if ( _System_state_Is_up(_System_state_Get ()) ) context_p = &_Thread_Executing->Registers; _Context_Switch( context_p, &_Thread_BSP_context ); 111b13: 03 45 10 add 0x10(%ebp),%eax <== NOT EXECUTED the_heap->end = _Addresses_Add_offset( the_heap->end, size ); 111b16: 89 41 1c mov %eax,0x1c(%ecx) <== NOT EXECUTED the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD; 111b19: 29 d8 sub %ebx,%eax <== NOT EXECUTED 111b1b: 8d 70 f8 lea -0x8(%eax),%esi <== NOT EXECUTED * the outer most dispatching critical section, then a dispatching * operation will be performed and, if necessary, control of the * processor will be transferred to the heir thread. */ #if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \ 111b1e: 89 f0 mov %esi,%eax <== NOT EXECUTED 111b20: 31 d2 xor %edx,%edx <== NOT EXECUTED 111b22: f7 71 10 divl 0x10(%ecx) <== NOT EXECUTED 111b25: 29 d6 sub %edx,%esi <== NOT EXECUTED 111b27: 89 f2 mov %esi,%edx <== NOT EXECUTED _Heap_Align_down( &the_size, the_heap->page_size ); *amount_extended = size; 111b29: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 111b2c: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 111b2f: 89 06 mov %eax,(%esi) <== NOT EXECUTED if( the_size < the_heap->min_block_size ) 111b31: 39 51 14 cmp %edx,0x14(%ecx) <== NOT EXECUTED 111b34: 76 06 jbe 111b3c <_Heap_Extend+0x68> <== NOT EXECUTED 111b36: 31 c0 xor %eax,%eax <== NOT EXECUTED 111b38: eb b9 jmp 111af3 <_Heap_Extend+0x1f> <== NOT EXECUTED 111b3a: 66 90 xchg %ax,%ax <== NOT EXECUTED return HEAP_EXTEND_SUCCESSFUL; old_final->size = the_size | (old_final->size & HEAP_PREV_USED); 111b3c: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 111b3f: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 111b42: 09 d0 or %edx,%eax <== NOT EXECUTED 111b44: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED /** @brief _Thread_Is_proxy_blocking * * status which indicates that a proxy is blocking, and FALSE otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking ( uint32_t code 111b47: 8d 04 13 lea (%ebx,%edx,1),%eax <== NOT EXECUTED new_final = _Heap_Block_at( old_final, the_size ); new_final->size = HEAP_PREV_USED; 111b4a: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) <== NOT EXECUTED the_heap->final = new_final; 111b51: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED stats->size += size; 111b54: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 111b57: 01 51 2c add %edx,0x2c(%ecx) <== NOT EXECUTED stats->used_blocks += 1; 111b5a: ff 41 40 incl 0x40(%ecx) <== NOT EXECUTED stats->frees -= 1; /* Don't count subsequent call as actual free() */ 111b5d: ff 49 50 decl 0x50(%ecx) <== NOT EXECUTED _Heap_Free( the_heap, _Heap_User_area( old_final ) ); 111b60: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111b63: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 111b66: 50 push %eax <== NOT EXECUTED 111b67: 51 push %ecx <== NOT EXECUTED 111b68: e8 77 b3 ff ff call 10cee4 <_Heap_Free> <== NOT EXECUTED 111b6d: 31 c0 xor %eax,%eax <== NOT EXECUTED 111b6f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111b72: e9 7c ff ff ff jmp 111af3 <_Heap_Extend+0x1f> <== NOT EXECUTED 0010f9d0 <_Heap_Free>: bool _Heap_Free( Heap_Control *the_heap, void *starting_address ) { 10f9d0: 55 push %ebp <== NOT EXECUTED 10f9d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f9d3: 57 push %edi <== NOT EXECUTED 10f9d4: 56 push %esi <== NOT EXECUTED 10f9d5: 53 push %ebx <== NOT EXECUTED 10f9d6: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10f9d9: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10f9dc: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED uint32_t the_size; uint32_t next_size; Heap_Statistics *const stats = &the_heap->stats; bool next_is_free; if ( !_Addresses_Is_in_range( 10f9df: 8b 77 24 mov 0x24(%edi),%esi <== NOT EXECUTED 10f9e2: 8b 4f 20 mov 0x20(%edi),%ecx <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10f9e5: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10f9e7: 77 04 ja 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED 10f9e9: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10f9eb: 73 0b jae 10f9f8 <_Heap_Free+0x28> <== NOT EXECUTED stats->used_blocks -= 1; stats->free_size += the_size; stats->frees += 1; return( TRUE ); 10f9ed: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10f9ef: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10f9f2: 5b pop %ebx <== NOT EXECUTED 10f9f3: 5e pop %esi <== NOT EXECUTED 10f9f4: 5f pop %edi <== NOT EXECUTED 10f9f5: c9 leave <== NOT EXECUTED 10f9f6: c3 ret <== NOT EXECUTED 10f9f7: 90 nop <== NOT EXECUTED 10f9f8: 8d 58 f8 lea -0x8(%eax),%ebx <== NOT EXECUTED 10f9fb: 31 d2 xor %edx,%edx <== NOT EXECUTED 10f9fd: f7 77 10 divl 0x10(%edi) <== NOT EXECUTED 10fa00: 29 d3 sub %edx,%ebx <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10fa02: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 10fa04: 77 e7 ja 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED 10fa06: 39 de cmp %ebx,%esi <== NOT EXECUTED 10fa08: 72 e3 jb 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED 10fa0a: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10fa0d: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 10fa10: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10fa13: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 10fa16: 01 d8 add %ebx,%eax <== NOT EXECUTED 10fa18: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10fa1b: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10fa1d: 77 ce ja 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED 10fa1f: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10fa21: 72 ca jb 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED 10fa23: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 10fa26: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED if ( !_Heap_Is_block_in( the_heap, next_block ) ) { _HAssert( FALSE ); return( FALSE ); } if ( !_Heap_Is_prev_used( next_block ) ) { 10fa29: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 10fa2c: 74 bf je 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED 10fa2e: 83 e2 fe and $0xfffffffe,%edx <== NOT EXECUTED 10fa31: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } next_size = _Heap_Block_size( next_block ); next_is_free = next_block < the_heap->final && 10fa34: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10fa36: 76 74 jbe 10faac <_Heap_Free+0xdc> <== NOT EXECUTED 10fa38: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10fa3b: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10fa3e: 8b 44 02 04 mov 0x4(%edx,%eax,1),%eax <== NOT EXECUTED 10fa42: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 10fa45: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10fa48: 8a 45 e0 mov -0x20(%ebp),%al <== NOT EXECUTED 10fa4b: 83 e0 01 and $0x1,%eax <== NOT EXECUTED !_Heap_Is_prev_used(_Heap_Block_at(next_block, next_size)); if ( !_Heap_Is_prev_used( the_block ) ) { 10fa4e: f6 45 dc 01 testb $0x1,-0x24(%ebp) <== NOT EXECUTED 10fa52: 75 5c jne 10fab0 <_Heap_Free+0xe0> <== NOT EXECUTED uint32_t const prev_size = the_block->prev_size; 10fa54: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10fa56: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 10fa59: 29 d3 sub %edx,%ebx <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10fa5b: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 10fa5d: 77 8e ja 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED 10fa5f: 39 de cmp %ebx,%esi <== NOT EXECUTED 10fa61: 72 8a jb 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED return( FALSE ); } /* As we always coalesce free blocks, the block that preceedes prev_block must have been used. */ if ( !_Heap_Is_prev_used ( prev_block) ) { 10fa63: f6 43 04 01 testb $0x1,0x4(%ebx) <== NOT EXECUTED 10fa67: 74 84 je 10f9ed <_Heap_Free+0x1d> <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } if ( next_is_free ) { /* coalesce both */ 10fa69: 84 c0 test %al,%al <== NOT EXECUTED 10fa6b: 0f 84 a0 00 00 00 je 10fb11 <_Heap_Free+0x141> <== NOT EXECUTED uint32_t const size = the_size + prev_size + next_size; 10fa71: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10fa74: 03 55 ec add -0x14(%ebp),%edx <== NOT EXECUTED 10fa77: 03 55 f0 add -0x10(%ebp),%edx <== NOT EXECUTED * Any other value of @a alignment is taken "as is", i.e., even odd * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon 10fa7a: 8b 75 e4 mov -0x1c(%ebp),%esi <== NOT EXECUTED 10fa7d: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes 10fa80: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED * @param[in] alignment the required alignment 10fa83: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10fa86: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED _Heap_Block_remove( next_block ); stats->free_blocks -= 1; 10fa89: ff 4f 38 decl 0x38(%edi) <== NOT EXECUTED prev_block->size = size | HEAP_PREV_USED; 10fa8c: 89 d0 mov %edx,%eax <== NOT EXECUTED 10fa8e: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10fa91: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; 10fa94: 89 14 13 mov %edx,(%ebx,%edx,1) <== NOT EXECUTED 10fa97: 90 nop <== NOT EXECUTED stats->free_blocks += 1; if ( stats->max_free_blocks < stats->free_blocks ) stats->max_free_blocks = stats->free_blocks; } stats->used_blocks -= 1; 10fa98: ff 4f 40 decl 0x40(%edi) <== NOT EXECUTED stats->free_size += the_size; 10fa9b: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 10fa9e: 01 77 30 add %esi,0x30(%edi) <== NOT EXECUTED stats->frees += 1; 10faa1: ff 47 50 incl 0x50(%edi) <== NOT EXECUTED 10faa4: b0 01 mov $0x1,%al <== NOT EXECUTED 10faa6: e9 44 ff ff ff jmp 10f9ef <_Heap_Free+0x1f> <== NOT EXECUTED 10faab: 90 nop <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } next_size = _Heap_Block_size( next_block ); next_is_free = next_block < the_heap->final && 10faac: 31 c0 xor %eax,%eax <== NOT EXECUTED 10faae: eb 9e jmp 10fa4e <_Heap_Free+0x7e> <== NOT EXECUTED prev_block->size = size | HEAP_PREV_USED; next_block->size &= ~HEAP_PREV_USED; next_block->prev_size = size; } } else if ( next_is_free ) { /* coalesce next */ 10fab0: 84 c0 test %al,%al <== NOT EXECUTED 10fab2: 74 28 je 10fadc <_Heap_Free+0x10c> <== NOT EXECUTED uint32_t const size = the_size + next_size; 10fab4: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10fab7: 03 55 e8 add -0x18(%ebp),%edx <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ 10faba: 8b 75 e4 mov -0x1c(%ebp),%esi <== NOT EXECUTED 10fabd: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED bool _Protected_heap_Get_block_size( 10fac0: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size 10fac3: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED ); 10fac6: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED 10fac9: 89 58 08 mov %ebx,0x8(%eax) <== NOT EXECUTED 10facc: 89 59 0c mov %ebx,0xc(%ecx) <== NOT EXECUTED _Heap_Block_replace( next_block, the_block ); the_block->size = size | HEAP_PREV_USED; 10facf: 89 d0 mov %edx,%eax <== NOT EXECUTED 10fad1: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10fad4: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block = _Heap_Block_at( the_block, size ); next_block->prev_size = size; 10fad7: 89 14 13 mov %edx,(%ebx,%edx,1) <== NOT EXECUTED 10fada: eb bc jmp 10fa98 <_Heap_Free+0xc8> <== NOT EXECUTED bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ); 10fadc: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED /** 10fadf: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED * This routine returns the block of memory which begins 10fae2: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10fae5: 89 5f 08 mov %ebx,0x8(%edi) <== NOT EXECUTED 10fae8: 89 58 0c mov %ebx,0xc(%eax) <== NOT EXECUTED } else { /* no coalesce */ /* Add 'the_block' to the head of the free blocks list as it tends to produce less fragmentation than adding to the tail. */ _Heap_Block_insert_after( _Heap_Head( the_heap), the_block ); the_block->size = the_size | HEAP_PREV_USED; 10faeb: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10faee: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10faf1: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block->size &= ~HEAP_PREV_USED; 10faf4: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10faf7: 83 60 04 fe andl $0xfffffffe,0x4(%eax) <== NOT EXECUTED next_block->prev_size = the_size; 10fafb: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10fafe: 89 10 mov %edx,(%eax) <== NOT EXECUTED stats->free_blocks += 1; 10fb00: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 10fb03: 40 inc %eax <== NOT EXECUTED 10fb04: 89 47 38 mov %eax,0x38(%edi) <== NOT EXECUTED if ( stats->max_free_blocks < stats->free_blocks ) 10fb07: 3b 47 3c cmp 0x3c(%edi),%eax <== NOT EXECUTED 10fb0a: 76 8c jbe 10fa98 <_Heap_Free+0xc8> <== NOT EXECUTED stats->max_free_blocks = stats->free_blocks; 10fb0c: 89 47 3c mov %eax,0x3c(%edi) <== NOT EXECUTED 10fb0f: eb 87 jmp 10fa98 <_Heap_Free+0xc8> <== NOT EXECUTED next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; } else { /* coalesce prev */ uint32_t const size = the_size + prev_size; 10fb11: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10fb14: 03 55 f0 add -0x10(%ebp),%edx <== NOT EXECUTED prev_block->size = size | HEAP_PREV_USED; 10fb17: 89 d0 mov %edx,%eax <== NOT EXECUTED 10fb19: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10fb1c: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block->size &= ~HEAP_PREV_USED; 10fb1f: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10fb22: 83 60 04 fe andl $0xfffffffe,0x4(%eax) <== NOT EXECUTED next_block->prev_size = size; 10fb26: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10fb28: e9 6b ff ff ff jmp 10fa98 <_Heap_Free+0xc8> <== NOT EXECUTED 00127034 <_Heap_Get_free_information>: void _Heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 127034: 55 push %ebp <== NOT EXECUTED 127035: 89 e5 mov %esp,%ebp <== NOT EXECUTED 127037: 53 push %ebx <== NOT EXECUTED 127038: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 12703b: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED Heap_Block *the_block; Heap_Block *const tail = _Heap_Tail(the_heap); info->number = 0; 12703e: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED info->largest = 0; 127044: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED info->total = 0; 12704b: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( 127052: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED for(the_block = _Heap_First(the_heap); the_block != tail; 127055: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 127057: 74 1d je 127076 <_Heap_Get_free_information+0x42> <== NOT EXECUTED 127059: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 12705c: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 12705f: 83 e0 fe and $0xfffffffe,%eax <== 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++; 127062: ff 01 incl (%ecx) <== NOT EXECUTED info->total += the_size; 127064: 01 41 08 add %eax,0x8(%ecx) <== NOT EXECUTED if ( info->largest < the_size ) 127067: 39 41 04 cmp %eax,0x4(%ecx) <== NOT EXECUTED 12706a: 73 03 jae 12706f <_Heap_Get_free_information+0x3b> <== NOT EXECUTED info->largest = the_size; 12706c: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; the_block = the_block->next) 12706f: 8b 52 08 mov 0x8(%edx),%edx <== NOT EXECUTED info->number = 0; info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; 127072: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 127074: 75 e6 jne 12705c <_Heap_Get_free_information+0x28> <== NOT EXECUTED info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 127076: 5b pop %ebx <== NOT EXECUTED 127077: c9 leave <== NOT EXECUTED 127078: c3 ret <== NOT EXECUTED 00130184 <_Heap_Get_information>: Heap_Get_information_status _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 130184: 55 push %ebp <== NOT EXECUTED 130185: 89 e5 mov %esp,%ebp <== NOT EXECUTED 130187: 56 push %esi <== NOT EXECUTED 130188: 53 push %ebx <== NOT EXECUTED 130189: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 13018c: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED Heap_Block *the_block = the_heap->start; 13018f: 8b 50 20 mov 0x20(%eax),%edx <== NOT EXECUTED Heap_Block *const end = the_heap->final; 130192: 8b 70 24 mov 0x24(%eax),%esi <== NOT EXECUTED _HAssert(the_block->prev_size == HEAP_PREV_USED); _HAssert(_Heap_Is_prev_used(the_block)); the_info->Free.number = 0; 130195: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED the_info->Free.total = 0; 13019b: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED the_info->Free.largest = 0; 1301a2: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED the_info->Used.number = 0; 1301a9: c7 41 0c 00 00 00 00 movl $0x0,0xc(%ecx) <== NOT EXECUTED the_info->Used.total = 0; 1301b0: c7 41 14 00 00 00 00 movl $0x0,0x14(%ecx) <== NOT EXECUTED the_info->Used.largest = 0; 1301b7: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx) <== NOT EXECUTED while ( the_block != end ) { 1301be: 39 f2 cmp %esi,%edx <== NOT EXECUTED 1301c0: 74 42 je 130204 <_Heap_Get_information+0x80> <== NOT EXECUTED 1301c2: 8b 5a 04 mov 0x4(%edx),%ebx <== NOT EXECUTED 1301c5: eb 13 jmp 1301da <_Heap_Get_information+0x56> <== NOT EXECUTED 1301c7: 90 nop <== NOT EXECUTED uint32_t const the_size = _Heap_Block_size(the_block); Heap_Block *const next_block = _Heap_Block_at(the_block, the_size); if ( _Heap_Is_prev_used(next_block) ) { the_info->Used.number++; 1301c8: ff 41 0c incl 0xc(%ecx) <== NOT EXECUTED the_info->Used.total += the_size; 1301cb: 01 41 14 add %eax,0x14(%ecx) <== NOT EXECUTED if ( the_info->Used.largest < the_size ) 1301ce: 39 41 10 cmp %eax,0x10(%ecx) <== NOT EXECUTED 1301d1: 73 03 jae 1301d6 <_Heap_Get_information+0x52> <== NOT EXECUTED the_info->Used.largest = the_size; 1301d3: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED the_info->Free.largest = 0; the_info->Used.number = 0; the_info->Used.total = 0; the_info->Used.largest = 0; while ( the_block != end ) { 1301d6: 39 d6 cmp %edx,%esi <== NOT EXECUTED 1301d8: 74 2a je 130204 <_Heap_Get_information+0x80> <== NOT EXECUTED 1301da: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1301dc: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 1301df: 01 c2 add %eax,%edx <== NOT EXECUTED 1301e1: 8b 5a 04 mov 0x4(%edx),%ebx <== NOT EXECUTED uint32_t const the_size = _Heap_Block_size(the_block); Heap_Block *const next_block = _Heap_Block_at(the_block, the_size); if ( _Heap_Is_prev_used(next_block) ) { 1301e4: f6 c3 01 test $0x1,%bl <== NOT EXECUTED 1301e7: 75 df jne 1301c8 <_Heap_Get_information+0x44> <== NOT EXECUTED the_info->Used.number++; the_info->Used.total += the_size; if ( the_info->Used.largest < the_size ) the_info->Used.largest = the_size; } else { the_info->Free.number++; 1301e9: ff 01 incl (%ecx) <== NOT EXECUTED the_info->Free.total += the_size; 1301eb: 01 41 08 add %eax,0x8(%ecx) <== NOT EXECUTED if ( the_info->Free.largest < the_size ) 1301ee: 39 41 04 cmp %eax,0x4(%ecx) <== NOT EXECUTED 1301f1: 73 03 jae 1301f6 <_Heap_Get_information+0x72> <== NOT EXECUTED the_info->Free.largest = the_size; 1301f3: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED if ( the_size != next_block->prev_size ) 1301f6: 39 02 cmp %eax,(%edx) <== NOT EXECUTED 1301f8: 74 dc je 1301d6 <_Heap_Get_information+0x52> <== NOT EXECUTED 1301fa: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED "used" as client never allocated it. Make 'Used.total' contain this blocks' overhead though. */ the_info->Used.total += HEAP_OVERHEAD; return HEAP_GET_INFORMATION_SUCCESSFUL; } 1301ff: 5b pop %ebx <== NOT EXECUTED 130200: 5e pop %esi <== NOT EXECUTED 130201: c9 leave <== NOT EXECUTED 130202: c3 ret <== NOT EXECUTED 130203: 90 nop <== NOT EXECUTED } /* Handle the last dummy block. Don't consider this block to be "used" as client never allocated it. Make 'Used.total' contain this blocks' overhead though. */ the_info->Used.total += HEAP_OVERHEAD; 130204: 83 41 14 08 addl $0x8,0x14(%ecx) <== NOT EXECUTED 130208: 31 c0 xor %eax,%eax <== NOT EXECUTED return HEAP_GET_INFORMATION_SUCCESSFUL; } 13020a: 5b pop %ebx <== NOT EXECUTED 13020b: 5e pop %esi <== NOT EXECUTED 13020c: c9 leave <== NOT EXECUTED 13020d: c3 ret <== NOT EXECUTED 0010b398 <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 10b398: 55 push %ebp <== NOT EXECUTED 10b399: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b39b: 57 push %edi <== NOT EXECUTED 10b39c: 56 push %esi <== NOT EXECUTED 10b39d: 53 push %ebx <== NOT EXECUTED 10b39e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b3a1: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b3a4: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED _H_uptr_t start; _H_uptr_t aligned_start; uint32_t overhead; Heap_Statistics *const stats = &the_heap->stats; if (page_size == 0) 10b3a7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b3a9: 0f 85 fd 00 00 00 jne 10b4ac <_Heap_Initialize+0x114> <== NOT EXECUTED 10b3af: b1 04 mov $0x4,%cl <== NOT EXECUTED 10b3b1: 31 f6 xor %esi,%esi <== 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; 10b3b3: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10b3b6: 83 c3 08 add $0x8,%ebx <== NOT EXECUTED 10b3b9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b3bb: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b3bd: f7 f1 div %ecx <== NOT EXECUTED 10b3bf: 85 d2 test %edx,%edx <== NOT EXECUTED 10b3c1: 74 05 je 10b3c8 <_Heap_Initialize+0x30> <== NOT EXECUTED 10b3c3: 8d 1c 19 lea (%ecx,%ebx,1),%ebx <== NOT EXECUTED 10b3c6: 29 d3 sub %edx,%ebx <== NOT EXECUTED _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 10b3c8: 83 eb 08 sub $0x8,%ebx <== NOT EXECUTED * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area * * @return true if successfully able to return information */ 10b3cb: 85 f6 test %esi,%esi <== NOT EXECUTED 10b3cd: 0f 85 cd 00 00 00 jne 10b4a0 <_Heap_Initialize+0x108> <== NOT EXECUTED 10b3d3: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 10b3d8: 89 47 14 mov %eax,0x14(%edi) <== NOT EXECUTED /* 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); 10b3db: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b3dd: 2b 45 0c sub 0xc(%ebp),%eax <== NOT EXECUTED 10b3e0: 83 c0 08 add $0x8,%eax <== NOT EXECUTED if ( size < overhead ) 10b3e3: 3b 45 10 cmp 0x10(%ebp),%eax <== NOT EXECUTED 10b3e6: 0f 87 a8 00 00 00 ja 10b494 <_Heap_Initialize+0xfc> <== NOT EXECUTED return 0; /* Too small area for the heap */ the_size = size - overhead; 10b3ec: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10b3ef: 29 c6 sub %eax,%esi <== NOT EXECUTED * * @return free block information filled in. */ bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info 10b3f1: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b3f3: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b3f5: f7 f1 div %ecx <== NOT EXECUTED _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 10b3f7: 29 d6 sub %edx,%esi <== NOT EXECUTED 10b3f9: 0f 84 95 00 00 00 je 10b494 <_Heap_Initialize+0xfc> <== NOT EXECUTED return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 10b3ff: 89 4f 10 mov %ecx,0x10(%edi) <== NOT EXECUTED the_heap->begin = starting_address; 10b402: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b405: 89 47 18 mov %eax,0x18(%edi) <== NOT EXECUTED the_heap->end = starting_address + size; 10b408: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b40b: 03 45 10 add 0x10(%ebp),%eax <== NOT EXECUTED 10b40e: 89 47 1c mov %eax,0x1c(%edi) <== NOT EXECUTED the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; 10b411: 89 0b mov %ecx,(%ebx) <== NOT EXECUTED the_block->size = the_size | HEAP_PREV_USED; 10b413: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b415: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10b418: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED the_block->next = _Heap_Tail( the_heap ); 10b41b: 89 7b 08 mov %edi,0x8(%ebx) <== NOT EXECUTED the_block->prev = _Heap_Head( the_heap ); 10b41e: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED _Heap_Head(the_heap)->next = the_block; 10b421: 89 5f 08 mov %ebx,0x8(%edi) <== NOT EXECUTED _Heap_Tail(the_heap)->prev = the_block; 10b424: 89 5f 0c mov %ebx,0xc(%edi) <== NOT EXECUTED the_heap->start = the_block; 10b427: 89 5f 20 mov %ebx,0x20(%edi) <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 10b42a: 8d 04 33 lea (%ebx,%esi,1),%eax <== NOT EXECUTED _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 */ 10b42d: 89 47 24 mov %eax,0x24(%edi) <== NOT EXECUTED the_block->prev_size = the_size; /* Previous block is free */ 10b430: 89 30 mov %esi,(%eax) <== NOT EXECUTED the_block->size = page_size; 10b432: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED stats->size = size; 10b435: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b438: 89 47 2c mov %eax,0x2c(%edi) <== NOT EXECUTED stats->free_size = the_size; 10b43b: 89 77 30 mov %esi,0x30(%edi) <== NOT EXECUTED stats->min_free_size = the_size; 10b43e: 89 77 34 mov %esi,0x34(%edi) <== NOT EXECUTED stats->free_blocks = 1; 10b441: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi) <== NOT EXECUTED stats->max_free_blocks = 1; 10b448: c7 47 3c 01 00 00 00 movl $0x1,0x3c(%edi) <== NOT EXECUTED stats->used_blocks = 0; 10b44f: c7 47 40 00 00 00 00 movl $0x0,0x40(%edi) <== NOT EXECUTED stats->max_search = 0; 10b456: c7 47 44 00 00 00 00 movl $0x0,0x44(%edi) <== NOT EXECUTED stats->allocs = 0; 10b45d: c7 47 48 00 00 00 00 movl $0x0,0x48(%edi) <== NOT EXECUTED stats->searches = 0; 10b464: c7 47 4c 00 00 00 00 movl $0x0,0x4c(%edi) <== NOT EXECUTED stats->frees = 0; 10b46b: c7 47 50 00 00 00 00 movl $0x0,0x50(%edi) <== NOT EXECUTED stats->resizes = 0; 10b472: c7 47 54 00 00 00 00 movl $0x0,0x54(%edi) <== NOT EXECUTED stats->instance = instance++; 10b479: a1 20 f5 11 00 mov 0x11f520,%eax <== NOT EXECUTED 10b47e: 89 47 28 mov %eax,0x28(%edi) <== NOT EXECUTED 10b481: 40 inc %eax <== NOT EXECUTED 10b482: a3 20 f5 11 00 mov %eax,0x11f520 <== NOT EXECUTED return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 10b487: 8d 46 fc lea -0x4(%esi),%eax <== NOT EXECUTED } 10b48a: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10b48d: 5b pop %ebx <== NOT EXECUTED 10b48e: 5e pop %esi <== NOT EXECUTED 10b48f: 5f pop %edi <== NOT EXECUTED 10b490: c9 leave <== NOT EXECUTED 10b491: c3 ret <== NOT EXECUTED 10b492: 66 90 xchg %ax,%ax <== NOT EXECUTED stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 10b494: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10b496: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10b499: 5b pop %ebx <== NOT EXECUTED 10b49a: 5e pop %esi <== NOT EXECUTED 10b49b: 5f pop %edi <== NOT EXECUTED 10b49c: c9 leave <== NOT EXECUTED 10b49d: c3 ret <== NOT EXECUTED 10b49e: 66 90 xchg %ax,%ax <== NOT EXECUTED * * @param[in] the_heap pointer to heap header * @param[in] the_info pointer to a status information area * * @return true if successfully able to return information */ 10b4a0: 8d 41 10 lea 0x10(%ecx),%eax <== NOT EXECUTED 10b4a3: 29 f0 sub %esi,%eax <== NOT EXECUTED 10b4a5: e9 2e ff ff ff jmp 10b3d8 <_Heap_Initialize+0x40> <== NOT EXECUTED 10b4aa: 66 90 xchg %ax,%ax <== NOT EXECUTED 10b4ac: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b4ae: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 10b4b1: 74 05 je 10b4b8 <_Heap_Initialize+0x120> <== NOT EXECUTED 10b4b3: 83 c1 04 add $0x4,%ecx <== NOT EXECUTED 10b4b6: 29 c1 sub %eax,%ecx <== NOT EXECUTED 10b4b8: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 10b4bd: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b4bf: f7 f1 div %ecx <== NOT EXECUTED 10b4c1: 89 d6 mov %edx,%esi <== NOT EXECUTED 10b4c3: e9 eb fe ff ff jmp 10b3b3 <_Heap_Initialize+0x1b> <== NOT EXECUTED 00117528 <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 117528: 55 push %ebp <== NOT EXECUTED 117529: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11752b: 57 push %edi <== NOT EXECUTED 11752c: 56 push %esi <== NOT EXECUTED 11752d: 53 push %ebx <== NOT EXECUTED 11752e: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 117531: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 117534: 8b 4d 0c mov 0xc(%ebp),%ecx <== 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; 117537: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 11753a: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED uint32_t const page_size = the_heap->page_size; 11753d: 8b 56 10 mov 0x10(%esi),%edx <== NOT EXECUTED 117540: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED *old_mem_size = 0; 117543: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 117546: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED *avail_mem_size = 0; 11754c: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 11754f: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 117555: 8d 59 f8 lea -0x8(%ecx),%ebx <== NOT EXECUTED 117558: 89 c8 mov %ecx,%eax <== NOT EXECUTED 11755a: 31 d2 xor %edx,%edx <== NOT EXECUTED 11755c: f7 76 10 divl 0x10(%esi) <== NOT EXECUTED 11755f: 29 d3 sub %edx,%ebx <== NOT EXECUTED 117561: 8b 56 24 mov 0x24(%esi),%edx <== NOT EXECUTED 117564: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED /* end of include file */ 117567: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 117569: 72 04 jb 11756f <_Heap_Resize_block+0x47> <== NOT EXECUTED 11756b: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 11756d: 76 0d jbe 11757c <_Heap_Resize_block+0x54> <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 11756f: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED } 117574: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 117577: 5b pop %ebx <== NOT EXECUTED 117578: 5e pop %esi <== NOT EXECUTED 117579: 5f pop %edi <== NOT EXECUTED 11757a: c9 leave <== NOT EXECUTED 11757b: c3 ret <== 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)) return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 11757c: 8b 7b 04 mov 0x4(%ebx),%edi <== NOT EXECUTED 11757f: 89 7d cc mov %edi,-0x34(%ebp) <== NOT EXECUTED 117582: 83 e7 fe and $0xfffffffe,%edi <== NOT EXECUTED 117585: 89 7d d8 mov %edi,-0x28(%ebp) <== NOT EXECUTED 117588: 01 df add %ebx,%edi <== NOT EXECUTED 11758a: 89 7d c0 mov %edi,-0x40(%ebp) <== NOT EXECUTED /* end of include file */ 11758d: 39 f8 cmp %edi,%eax <== NOT EXECUTED 11758f: 77 de ja 11756f <_Heap_Resize_block+0x47> <== NOT EXECUTED 117591: 39 fa cmp %edi,%edx <== NOT EXECUTED 117593: 72 da jb 11756f <_Heap_Resize_block+0x47> <== NOT EXECUTED 117595: 8b 47 04 mov 0x4(%edi),%eax <== 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) || 117598: a8 01 test $0x1,%al <== NOT EXECUTED 11759a: 74 d3 je 11756f <_Heap_Resize_block+0x47> <== NOT EXECUTED 11759c: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 11759f: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 1175a2: 01 f8 add %edi,%eax <== NOT EXECUTED 1175a4: 89 45 d4 mov %eax,-0x2c(%ebp) <== 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) || 1175a7: 39 fa cmp %edi,%edx <== NOT EXECUTED 1175a9: 0f 84 11 01 00 00 je 1176c0 <_Heap_Resize_block+0x198> <== NOT EXECUTED 1175af: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 1175b2: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 1175b5: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 1175b8: 88 45 f3 mov %al,-0xd(%ebp) <== 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)) return HEAP_RESIZE_FATAL_ERROR; prev_used_flag = the_block->size & HEAP_PREV_USED; 1175bb: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED 1175be: 83 e7 01 and $0x1,%edi <== NOT EXECUTED 1175c1: 89 7d dc mov %edi,-0x24(%ebp) <== NOT EXECUTED next_next_block = _Heap_Block_at(next_block, next_block_size); next_is_used = (next_block == the_heap->final) || _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) 1175c4: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 1175c7: 29 c8 sub %ecx,%eax <== NOT EXECUTED 1175c9: 83 c0 04 add $0x4,%eax <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 1175cc: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 1175cf: 89 02 mov %eax,(%edx) <== NOT EXECUTED if (size > old_user_size) { 1175d1: 3b 45 10 cmp 0x10(%ebp),%eax <== NOT EXECUTED 1175d4: 73 3a jae 117610 <_Heap_Resize_block+0xe8> <== 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 */ 1175d6: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 1175da: 75 29 jne 117605 <_Heap_Resize_block+0xdd> <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; else { uint32_t add_block_size = size - old_user_size; 1175dc: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 1175df: 29 c1 sub %eax,%ecx <== NOT EXECUTED 1175e1: 89 c8 mov %ecx,%eax <== NOT EXECUTED 1175e3: 31 d2 xor %edx,%edx <== NOT EXECUTED 1175e5: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED 1175e8: 85 d2 test %edx,%edx <== NOT EXECUTED 1175ea: 74 05 je 1175f1 <_Heap_Resize_block+0xc9> <== NOT EXECUTED 1175ec: 03 4d e4 add -0x1c(%ebp),%ecx <== NOT EXECUTED 1175ef: 29 d1 sub %edx,%ecx <== NOT EXECUTED 1175f1: 89 c8 mov %ecx,%eax <== NOT EXECUTED 1175f3: 3b 4d e0 cmp -0x20(%ebp),%ecx <== NOT EXECUTED 1175f6: 0f 82 a0 00 00 00 jb 11769c <_Heap_Resize_block+0x174> <== 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) 1175fc: 39 45 d0 cmp %eax,-0x30(%ebp) <== NOT EXECUTED 1175ff: 0f 83 9f 00 00 00 jae 1176a4 <_Heap_Resize_block+0x17c> <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 117605: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 11760a: e9 65 ff ff ff jmp 117574 <_Heap_Resize_block+0x4c> <== NOT EXECUTED 11760f: 90 nop <== NOT EXECUTED --stats->used_blocks; } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 117610: 89 c1 mov %eax,%ecx <== NOT EXECUTED 117612: 2b 4d 10 sub 0x10(%ebp),%ecx <== NOT EXECUTED 117615: 89 c8 mov %ecx,%eax <== NOT EXECUTED 117617: 31 d2 xor %edx,%edx <== NOT EXECUTED 117619: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 11761c: 29 d1 sub %edx,%ecx <== NOT EXECUTED 11761e: 89 4d e8 mov %ecx,-0x18(%ebp) <== NOT EXECUTED 117621: 74 69 je 11768c <_Heap_Resize_block+0x164> <== 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; 117623: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 117626: 29 ca sub %ecx,%edx <== NOT EXECUTED 117628: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED if (new_block_size < min_block_size) { 11762b: 39 55 e0 cmp %edx,-0x20(%ebp) <== NOT EXECUTED 11762e: 76 0d jbe 11763d <_Heap_Resize_block+0x115> <== NOT EXECUTED uint32_t delta = min_block_size - new_block_size; 117630: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 117633: 29 d0 sub %edx,%eax <== NOT EXECUTED _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 117635: 29 45 e8 sub %eax,-0x18(%ebp) <== NOT EXECUTED 117638: 74 52 je 11768c <_Heap_Resize_block+0x164> <== NOT EXECUTED ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; } new_block_size += delta; 11763a: 01 45 ec add %eax,-0x14(%ebp) <== 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) { 11763d: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 117641: 0f 85 85 00 00 00 jne 1176cc <_Heap_Resize_block+0x1a4> <== NOT EXECUTED 117647: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 11764a: 8d 14 3b lea (%ebx,%edi,1),%edx <== NOT EXECUTED /* 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; 11764d: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 117650: 03 4d d0 add -0x30(%ebp),%ecx <== NOT EXECUTED _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; 117653: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 117656: 09 c7 or %eax,%edi <== NOT EXECUTED 117658: 89 7b 04 mov %edi,0x4(%ebx) <== NOT EXECUTED new_next_block->size = new_next_block_size | HEAP_PREV_USED; 11765b: 89 c8 mov %ecx,%eax <== NOT EXECUTED 11765d: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 117660: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED next_next_block->prev_size = new_next_block_size; 117663: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED 117666: 89 0f mov %ecx,(%edi) <== NOT EXECUTED { return (state == SYSTEM_STATE_FAILED); } /**@}*/ 117668: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 11766b: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED #endif 11766e: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED /* end of include file */ 117671: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED 117674: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 117677: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED 11767a: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED _Heap_Block_replace(next_block, new_next_block); the_heap->stats.free_size += free_block_size; 11767d: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 117680: 01 46 30 add %eax,0x30(%esi) <== NOT EXECUTED *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 117683: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED 117686: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 117689: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 11768b: 90 nop <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; } } } ++stats->resizes; 11768c: ff 46 54 incl 0x54(%esi) <== NOT EXECUTED 11768f: 31 c0 xor %eax,%eax <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; } 117691: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 117694: 5b pop %ebx <== NOT EXECUTED 117695: 5e pop %esi <== NOT EXECUTED 117696: 5f pop %edi <== NOT EXECUTED 117697: c9 leave <== NOT EXECUTED 117698: c3 ret <== NOT EXECUTED 117699: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 11769c: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 11769f: e9 58 ff ff ff jmp 1175fc <_Heap_Resize_block+0xd4> <== 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) return HEAP_RESIZE_UNSATISFIED; /* Next block is too small or none. */ add_block_size = 1176a4: 52 push %edx <== NOT EXECUTED 1176a5: 50 push %eax <== NOT EXECUTED 1176a6: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED 1176a9: 56 push %esi <== NOT EXECUTED 1176aa: e8 4d 3e ff ff call 10b4fc <_Heap_Block_allocate> <== 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; 1176af: 03 45 d8 add -0x28(%ebp),%eax <== NOT EXECUTED 1176b2: 0b 45 dc or -0x24(%ebp),%eax <== NOT EXECUTED 1176b5: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED --stats->used_blocks; 1176b8: ff 4e 40 decl 0x40(%esi) <== NOT EXECUTED 1176bb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1176be: eb cc jmp 11768c <_Heap_Resize_block+0x164> <== 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) || 1176c0: c6 45 f3 01 movb $0x1,-0xd(%ebp) <== NOT EXECUTED 1176c4: e9 f2 fe ff ff jmp 1175bb <_Heap_Resize_block+0x93> <== NOT EXECUTED 1176c9: 8d 76 00 lea 0x0(%esi),%esi <== 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; *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; } else if (free_block_size >= min_block_size) { 1176cc: 8b 7d e8 mov -0x18(%ebp),%edi <== NOT EXECUTED 1176cf: 39 7d e0 cmp %edi,-0x20(%ebp) <== NOT EXECUTED 1176d2: 77 b8 ja 11768c <_Heap_Resize_block+0x164> <== NOT EXECUTED /* Split the block into 2 used parts, then free the second one. */ the_block->size = new_block_size | prev_used_flag; 1176d4: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1176d7: 09 45 dc or %eax,-0x24(%ebp) <== NOT EXECUTED 1176da: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 1176dd: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 1176e0: 8d 04 03 lea (%ebx,%eax,1),%eax <== NOT EXECUTED next_block = _Heap_Block_at(the_block, new_block_size); next_block->size = free_block_size | HEAP_PREV_USED; 1176e3: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 1176e6: 83 ca 01 or $0x1,%edx <== NOT EXECUTED 1176e9: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 1176ec: ff 46 40 incl 0x40(%esi) <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 1176ef: ff 4e 50 decl 0x50(%esi) <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 1176f2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1176f5: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 1176f8: 50 push %eax <== NOT EXECUTED 1176f9: 56 push %esi <== NOT EXECUTED 1176fa: e8 d1 82 ff ff call 10f9d0 <_Heap_Free> <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 1176ff: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 117702: 83 e8 04 sub $0x4,%eax <== NOT EXECUTED 117705: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 117708: 89 02 mov %eax,(%edx) <== NOT EXECUTED 11770a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11770d: e9 7a ff ff ff jmp 11768c <_Heap_Resize_block+0x164> <== NOT EXECUTED 00117714 <_Heap_Size_of_user_area>: bool _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 117714: 55 push %ebp <== NOT EXECUTED 117715: 89 e5 mov %esp,%ebp <== NOT EXECUTED 117717: 57 push %edi <== NOT EXECUTED 117718: 56 push %esi <== NOT EXECUTED 117719: 53 push %ebx <== NOT EXECUTED 11771a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11771d: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Heap_Block *the_block; Heap_Block *next_block; uint32_t the_size; if ( !_Addresses_Is_in_range( 117720: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 117723: 8b 70 24 mov 0x24(%eax),%esi <== NOT EXECUTED 117726: 8b 48 20 mov 0x20(%eax),%ecx <== NOT EXECUTED /* end of include file */ 117729: 39 f9 cmp %edi,%ecx <== NOT EXECUTED 11772b: 77 04 ja 117731 <_Heap_Size_of_user_area+0x1d> <== NOT EXECUTED 11772d: 39 fe cmp %edi,%esi <== NOT EXECUTED 11772f: 73 0b jae 11773c <_Heap_Size_of_user_area+0x28> <== NOT EXECUTED area of 'the_block'. */ *size = _Addresses_Subtract ( next_block, starting_address ) + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); 117731: 31 c0 xor %eax,%eax <== NOT EXECUTED } 117733: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 117736: 5b pop %ebx <== NOT EXECUTED 117737: 5e pop %esi <== NOT EXECUTED 117738: 5f pop %edi <== NOT EXECUTED 117739: c9 leave <== NOT EXECUTED 11773a: c3 ret <== NOT EXECUTED 11773b: 90 nop <== NOT EXECUTED 11773c: 8d 57 f8 lea -0x8(%edi),%edx <== NOT EXECUTED 11773f: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 117742: 89 f8 mov %edi,%eax <== NOT EXECUTED 117744: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 117747: 31 d2 xor %edx,%edx <== NOT EXECUTED 117749: f7 73 10 divl 0x10(%ebx) <== NOT EXECUTED 11774c: 29 55 e8 sub %edx,-0x18(%ebp) <== NOT EXECUTED /* end of include file */ 11774f: 3b 4d e8 cmp -0x18(%ebp),%ecx <== NOT EXECUTED 117752: 77 dd ja 117731 <_Heap_Size_of_user_area+0x1d> <== NOT EXECUTED 117754: 3b 75 e8 cmp -0x18(%ebp),%esi <== NOT EXECUTED 117757: 72 d8 jb 117731 <_Heap_Size_of_user_area+0x1d> <== NOT EXECUTED 117759: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 11775c: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 11775f: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 117762: 01 d0 add %edx,%eax <== NOT EXECUTED /* end of include file */ 117764: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 117766: 77 c9 ja 117731 <_Heap_Size_of_user_area+0x1d> <== NOT EXECUTED 117768: 39 c6 cmp %eax,%esi <== NOT EXECUTED 11776a: 72 c5 jb 117731 <_Heap_Size_of_user_area+0x1d> <== 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 ( 11776c: f6 40 04 01 testb $0x1,0x4(%eax) <== NOT EXECUTED 117770: 74 bf je 117731 <_Heap_Size_of_user_area+0x1d> <== 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 ) 117772: 29 f8 sub %edi,%eax <== NOT EXECUTED 117774: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 117777: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 11777a: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 11777c: b0 01 mov $0x1,%al <== NOT EXECUTED 11777e: eb b3 jmp 117733 <_Heap_Size_of_user_area+0x1f> <== NOT EXECUTED 00111cb8 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 111cb8: 55 push %ebp <== NOT EXECUTED 111cb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111cbb: 57 push %edi <== NOT EXECUTED 111cbc: 56 push %esi <== NOT EXECUTED 111cbd: 53 push %ebx <== NOT EXECUTED 111cbe: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 111cc1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Heap_Block *the_block = the_heap->start; 111cc4: 8b 7e 20 mov 0x20(%esi),%edi <== NOT EXECUTED Heap_Block *const end = the_heap->final; 111cc7: 8b 46 24 mov 0x24(%esi),%eax <== NOT EXECUTED 111cca: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED /* if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) 111ccd: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 111cd0: 85 c0 test %eax,%eax <== NOT EXECUTED 111cd2: 0f 88 67 02 00 00 js 111f3f <_Heap_Walk+0x287> <== NOT EXECUTED /* * Handle the 1st block */ if (!_Heap_Is_prev_used(the_block)) { 111cd8: f6 47 04 01 testb $0x1,0x4(%edi) <== NOT EXECUTED 111cdc: 0f 84 3e 02 00 00 je 111f20 <_Heap_Walk+0x268> <== NOT EXECUTED 111ce2: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp) <== NOT EXECUTED printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source); error = 1; } if (the_block->prev_size != the_heap->page_size) { 111ce9: 8b 07 mov (%edi),%eax <== NOT EXECUTED 111ceb: 3b 46 10 cmp 0x10(%esi),%eax <== NOT EXECUTED 111cee: 74 1a je 111d0a <_Heap_Walk+0x52> <== NOT EXECUTED printk("PASS: %d !prev_size of 1st block isn't page_size\n", source); 111cf0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111cf3: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111cf6: 68 b0 dc 11 00 push $0x11dcb0 <== NOT EXECUTED 111cfb: e8 80 76 ff ff call 109380 <== NOT EXECUTED 111d00: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111d07: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } while ( the_block != end ) { 111d0a: 3b 7d e4 cmp -0x1c(%ebp),%edi <== NOT EXECUTED 111d0d: 0f 84 37 02 00 00 je 111f4a <_Heap_Walk+0x292> <== NOT EXECUTED 111d13: 8b 57 04 mov 0x4(%edi),%edx <== NOT EXECUTED 111d16: 89 d3 mov %edx,%ebx <== NOT EXECUTED 111d18: 83 e3 fe and $0xfffffffe,%ebx <== NOT EXECUTED /** @brief _Thread_Is_proxy_blocking * * status which indicates that a proxy is blocking, and FALSE otherwise. */ RTEMS_INLINE_ROUTINE bool _Thread_Is_proxy_blocking ( uint32_t code 111d1b: 8d 04 1f lea (%edi,%ebx,1),%eax <== NOT EXECUTED 111d1e: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 111d21: 8b 46 24 mov 0x24(%esi),%eax <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 111d24: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 111d27: 39 4e 20 cmp %ecx,0x20(%esi) <== NOT EXECUTED 111d2a: 0f 87 14 01 00 00 ja 111e44 <_Heap_Walk+0x18c> <== NOT EXECUTED 111d30: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 111d32: 0f 87 0c 01 00 00 ja 111e44 <_Heap_Walk+0x18c> <== NOT EXECUTED 111d38: 83 e2 01 and $0x1,%edx <== NOT EXECUTED 111d3b: 88 55 f3 mov %dl,-0xd(%ebp) <== NOT EXECUTED 111d3e: 66 90 xchg %ax,%ax <== NOT EXECUTED printk("PASS: %d !block %p is out of heap\n", source, next_block); error = 1; break; } if (!_Heap_Is_prev_used(next_block)) { 111d40: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 111d43: f6 41 04 01 testb $0x1,0x4(%ecx) <== NOT EXECUTED 111d47: 0f 85 53 01 00 00 jne 111ea0 <_Heap_Walk+0x1e8> <== NOT EXECUTED if (do_dump) printk( " prev %p next %p", the_block->prev, the_block->next); if (_Heap_Block_size(the_block) != next_block->prev_size) { 111d4d: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 111d50: 39 18 cmp %ebx,(%eax) <== NOT EXECUTED 111d52: 74 1a je 111d6e <_Heap_Walk+0xb6> <== NOT EXECUTED if (do_dump) printk("\n"); printk("PASS: %d !front and back sizes don't match", source); 111d54: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111d57: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111d5a: 68 08 dd 11 00 push $0x11dd08 <== NOT EXECUTED 111d5f: e8 1c 76 ff ff call 109380 <== NOT EXECUTED 111d64: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111d6b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } if (!prev_used) { 111d6e: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 111d72: 75 25 jne 111d99 <_Heap_Walk+0xe1> <== NOT EXECUTED if (do_dump || error) printk("\n"); 111d74: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 111d77: 85 c0 test %eax,%eax <== NOT EXECUTED 111d79: 0f 85 81 01 00 00 jne 111f00 <_Heap_Walk+0x248> <== NOT EXECUTED printk("PASS: %d !two consecutive blocks are free", source); 111d7f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111d82: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111d85: 68 34 dd 11 00 push $0x11dd34 <== NOT EXECUTED 111d8a: e8 f1 75 ff ff call 109380 <== NOT EXECUTED 111d8f: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111d96: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { return ( the_thread == _Thread_Heir ); } /** 111d99: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED error = 1; } { /* Check if 'the_block' is in the free block list */ Heap_Block* block = _Heap_First(the_heap); while(block != the_block && block != tail) 111d9c: 39 c7 cmp %eax,%edi <== NOT EXECUTED 111d9e: 75 13 jne 111db3 <_Heap_Walk+0xfb> <== NOT EXECUTED 111da0: e9 fb 00 00 00 jmp 111ea0 <_Heap_Walk+0x1e8> <== NOT EXECUTED 111da5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED block = block->next; 111da8: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED error = 1; } { /* Check if 'the_block' is in the free block list */ Heap_Block* block = _Heap_First(the_heap); while(block != the_block && block != tail) 111dab: 39 f8 cmp %edi,%eax <== NOT EXECUTED 111dad: 0f 84 ed 00 00 00 je 111ea0 <_Heap_Walk+0x1e8> <== NOT EXECUTED 111db3: 39 c6 cmp %eax,%esi <== NOT EXECUTED 111db5: 75 f1 jne 111da8 <_Heap_Walk+0xf0> <== NOT EXECUTED block = block->next; if(block != the_block) { if (do_dump || error) printk("\n"); 111db7: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 111dba: 85 c9 test %ecx,%ecx <== NOT EXECUTED 111dbc: 74 10 je 111dce <_Heap_Walk+0x116> <== NOT EXECUTED 111dbe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111dc1: 68 87 b6 11 00 push $0x11b687 <== NOT EXECUTED 111dc6: e8 b5 75 ff ff call 109380 <== NOT EXECUTED 111dcb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED printk("PASS: %d !the_block not in the free list", source); 111dce: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111dd1: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111dd4: 68 60 dd 11 00 push $0x11dd60 <== NOT EXECUTED 111dd9: e8 a2 75 ff ff call 109380 <== NOT EXECUTED 111dde: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111de5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } } } if (do_dump || error) printk("\n"); 111de8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111deb: 68 87 b6 11 00 push $0x11b687 <== NOT EXECUTED 111df0: e8 8b 75 ff ff call 109380 <== NOT EXECUTED 111df5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (the_size < the_heap->min_block_size) { 111df8: 3b 5e 14 cmp 0x14(%esi),%ebx <== NOT EXECUTED 111dfb: 0f 82 b3 00 00 00 jb 111eb4 <_Heap_Walk+0x1fc> <== NOT EXECUTED printk("PASS: %d !block size is too small\n", source); error = 1; break; } if (!_Heap_Is_aligned( the_size, the_heap->page_size)) { 111e01: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111e03: 31 d2 xor %edx,%edx <== NOT EXECUTED 111e05: f7 76 10 divl 0x10(%esi) <== NOT EXECUTED 111e08: 85 d2 test %edx,%edx <== NOT EXECUTED 111e0a: 0f 85 d8 00 00 00 jne 111ee8 <_Heap_Walk+0x230> <== NOT EXECUTED printk("PASS: %d !block size is misaligned\n", source); error = 1; } if (++passes > (do_dump ? 10 : 0) && error) 111e10: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 111e13: 85 c0 test %eax,%eax <== NOT EXECUTED 111e15: 75 41 jne 111e58 <_Heap_Walk+0x1a0> <== NOT EXECUTED if (the_block->prev_size != the_heap->page_size) { printk("PASS: %d !prev_size of 1st block isn't page_size\n", source); error = 1; } while ( the_block != end ) { 111e17: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 111e1a: 39 4d e4 cmp %ecx,-0x1c(%ebp) <== NOT EXECUTED 111e1d: 0f 84 27 01 00 00 je 111f4a <_Heap_Walk+0x292> <== NOT EXECUTED 111e23: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 111e26: 8b 48 04 mov 0x4(%eax),%ecx <== NOT EXECUTED 111e29: 89 cb mov %ecx,%ebx <== NOT EXECUTED 111e2b: 83 e3 fe and $0xfffffffe,%ebx <== NOT EXECUTED Context_Control *context_p = &context_area; if ( _System_state_Is_up(_System_state_Get ()) ) context_p = &_Thread_Executing->Registers; _Context_Switch( context_p, &_Thread_BSP_context ); 111e2e: 01 d8 add %ebx,%eax <== NOT EXECUTED 111e30: 8b 56 24 mov 0x24(%esi),%edx <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 111e33: 3b 46 20 cmp 0x20(%esi),%eax <== NOT EXECUTED 111e36: 0f 83 90 00 00 00 jae 111ecc <_Heap_Walk+0x214> <== NOT EXECUTED printk("PASS: %d !block %p is out of heap\n", source, next_block); error = 1; break; } if (!_Heap_Is_prev_used(next_block)) { 111e3c: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 111e3f: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 111e42: 66 90 xchg %ax,%ax <== NOT EXECUTED printk(" (prev_size) %d", the_block->prev_size); } if (!_Heap_Is_block_in(the_heap, next_block)) { if (do_dump) printk("\n"); printk("PASS: %d !block %p is out of heap\n", source, next_block); 111e44: 50 push %eax <== NOT EXECUTED 111e45: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 111e48: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111e4b: 68 e4 dc 11 00 push $0x11dce4 <== NOT EXECUTED 111e50: e8 2b 75 ff ff call 109380 <== NOT EXECUTED 111e55: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_block = next_block; } if (the_block != end) { printk("PASS: %d !last block address isn't equal to 'final' %p %p\n", 111e58: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 111e5b: 57 push %edi <== NOT EXECUTED 111e5c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111e5f: 68 d4 dd 11 00 push $0x11ddd4 <== NOT EXECUTED 111e64: e8 17 75 ff ff call 109380 <== NOT EXECUTED 111e69: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111e70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111e73: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 111e76: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED source, the_block, end); error = 1; } if (_Heap_Block_size(the_block) != the_heap->page_size) { 111e79: 8b 56 10 mov 0x10(%esi),%edx <== NOT EXECUTED 111e7c: 39 c2 cmp %eax,%edx <== NOT EXECUTED 111e7e: 0f 84 91 00 00 00 je 111f15 <_Heap_Walk+0x25d> <== NOT EXECUTED printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source, 111e84: 52 push %edx <== NOT EXECUTED 111e85: 50 push %eax <== NOT EXECUTED 111e86: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111e89: 68 10 de 11 00 push $0x11de10 <== NOT EXECUTED 111e8e: e8 ed 74 ff ff call 109380 <== NOT EXECUTED 111e93: b0 01 mov $0x1,%al <== NOT EXECUTED 111e95: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if(do_dump && error) _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 ); return error; } 111e98: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111e9b: 5b pop %ebx <== NOT EXECUTED 111e9c: 5e pop %esi <== NOT EXECUTED 111e9d: 5f pop %edi <== NOT EXECUTED 111e9e: c9 leave <== NOT EXECUTED 111e9f: c3 ret <== NOT EXECUTED error = 1; } } } if (do_dump || error) printk("\n"); 111ea0: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 111ea3: 85 d2 test %edx,%edx <== NOT EXECUTED 111ea5: 0f 85 3d ff ff ff jne 111de8 <_Heap_Walk+0x130> <== NOT EXECUTED if (the_size < the_heap->min_block_size) { 111eab: 3b 5e 14 cmp 0x14(%esi),%ebx <== NOT EXECUTED 111eae: 0f 83 4d ff ff ff jae 111e01 <_Heap_Walk+0x149> <== NOT EXECUTED printk("PASS: %d !block size is too small\n", source); 111eb4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111eb7: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111eba: 68 8c dd 11 00 push $0x11dd8c <== NOT EXECUTED 111ebf: e8 bc 74 ff ff call 109380 <== NOT EXECUTED 111ec4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111ec7: eb 8f jmp 111e58 <_Heap_Walk+0x1a0> <== NOT EXECUTED 111ec9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp ( const Thread_Control *the_thread ) { return ( the_thread == _Thread_Allocated_fp ); 111ecc: 39 d0 cmp %edx,%eax <== NOT EXECUTED 111ece: 0f 87 68 ff ff ff ja 111e3c <_Heap_Walk+0x184> <== NOT EXECUTED 111ed4: 83 e1 01 and $0x1,%ecx <== NOT EXECUTED 111ed7: 88 4d f3 mov %cl,-0xd(%ebp) <== NOT EXECUTED 111eda: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 111edd: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 111ee0: e9 5b fe ff ff jmp 111d40 <_Heap_Walk+0x88> <== NOT EXECUTED 111ee5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED error = 1; break; } if (!_Heap_Is_aligned( the_size, the_heap->page_size)) { printk("PASS: %d !block size is misaligned\n", source); 111ee8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111eeb: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111eee: 68 b0 dd 11 00 push $0x11ddb0 <== NOT EXECUTED 111ef3: e8 88 74 ff ff call 109380 <== NOT EXECUTED 111ef8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111efb: e9 58 ff ff ff jmp 111e58 <_Heap_Walk+0x1a0> <== NOT EXECUTED if (do_dump) printk("\n"); printk("PASS: %d !front and back sizes don't match", source); error = 1; } if (!prev_used) { if (do_dump || error) printk("\n"); 111f00: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111f03: 68 87 b6 11 00 push $0x11b687 <== NOT EXECUTED 111f08: e8 73 74 ff ff call 109380 <== NOT EXECUTED 111f0d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111f10: e9 6a fe ff ff jmp 111d7f <_Heap_Walk+0xc7> <== NOT EXECUTED printk("PASS: %d !last block address isn't equal to 'final' %p %p\n", source, the_block, end); error = 1; } if (_Heap_Block_size(the_block) != the_heap->page_size) { 111f15: 8a 45 e8 mov -0x18(%ebp),%al <== NOT EXECUTED if(do_dump && error) _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 ); return error; } 111f18: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111f1b: 5b pop %ebx <== NOT EXECUTED 111f1c: 5e pop %esi <== NOT EXECUTED 111f1d: 5f pop %edi <== NOT EXECUTED 111f1e: c9 leave <== NOT EXECUTED 111f1f: c3 ret <== NOT EXECUTED /* * Handle the 1st block */ if (!_Heap_Is_prev_used(the_block)) { printk("PASS: %d !HEAP_PREV_USED flag of 1st block isn't set\n", source); 111f20: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111f23: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111f26: 68 78 dc 11 00 push $0x11dc78 <== NOT EXECUTED 111f2b: e8 50 74 ff ff call 109380 <== NOT EXECUTED 111f30: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111f37: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111f3a: e9 aa fd ff ff jmp 111ce9 <_Heap_Walk+0x31> <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) source = the_heap->stats.instance; 111f3f: 8b 4e 28 mov 0x28(%esi),%ecx <== NOT EXECUTED 111f42: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED 111f45: e9 8e fd ff ff jmp 111cd8 <_Heap_Walk+0x20> <== NOT EXECUTED source, the_block, end); error = 1; } if (_Heap_Block_size(the_block) != the_heap->page_size) { printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source, 111f4a: 8b 7d e4 mov -0x1c(%ebp),%edi <== NOT EXECUTED 111f4d: e9 21 ff ff ff jmp 111e73 <_Heap_Walk+0x1bb> <== NOT EXECUTED 0010aa5c <_IO_Initialize_all_drivers>: * * Output Parameters: NONE */ void _IO_Initialize_all_drivers( void ) { 10aa5c: 55 push %ebp <== NOT EXECUTED 10aa5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa5f: 53 push %ebx <== NOT EXECUTED 10aa60: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10aa63: 8b 15 20 02 12 00 mov 0x120220,%edx <== NOT EXECUTED 10aa69: 85 d2 test %edx,%edx <== NOT EXECUTED 10aa6b: 74 1a je 10aa87 <_IO_Initialize_all_drivers+0x2b> <== NOT EXECUTED 10aa6d: 31 db xor %ebx,%ebx <== NOT EXECUTED 10aa6f: 90 nop <== NOT EXECUTED (void) rtems_io_initialize( major, 0, NULL ); 10aa70: 50 push %eax <== NOT EXECUTED 10aa71: 6a 00 push $0x0 <== NOT EXECUTED 10aa73: 6a 00 push $0x0 <== NOT EXECUTED 10aa75: 53 push %ebx <== NOT EXECUTED 10aa76: e8 fd 4b 00 00 call 10f678 <== NOT EXECUTED void _IO_Initialize_all_drivers( void ) { rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10aa7b: 43 inc %ebx <== NOT EXECUTED 10aa7c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aa7f: 39 1d 20 02 12 00 cmp %ebx,0x120220 <== NOT EXECUTED 10aa85: 77 e9 ja 10aa70 <_IO_Initialize_all_drivers+0x14> <== NOT EXECUTED (void) rtems_io_initialize( major, 0, NULL ); } 10aa87: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aa8a: c9 leave <== NOT EXECUTED 10aa8b: c3 ret <== NOT EXECUTED 0010aa8c <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 10aa8c: 55 push %ebp <== NOT EXECUTED 10aa8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa8f: 57 push %edi <== NOT EXECUTED 10aa90: 56 push %esi <== NOT EXECUTED 10aa91: 53 push %ebx <== NOT EXECUTED 10aa92: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa95: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED /* * 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 ) 10aa98: 3b 75 0c cmp 0xc(%ebp),%esi <== NOT EXECUTED 10aa9b: 76 5b jbe 10aaf8 <_IO_Manager_initialization+0x6c> <== 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 *) 10aa9d: 8d 04 76 lea (%esi,%esi,2),%eax <== NOT EXECUTED 10aaa0: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx <== NOT EXECUTED 10aaa7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aaaa: 53 push %ebx <== NOT EXECUTED 10aaab: e8 e8 29 00 00 call 10d498 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10aab0: 89 c7 mov %eax,%edi <== NOT EXECUTED 10aab2: a3 24 02 12 00 mov %eax,0x120224 <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 10aab7: 89 35 20 02 12 00 mov %esi,0x120220 <== NOT EXECUTED memset( 10aabd: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aabf: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10aac1: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 10aac3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aac6: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10aac9: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10aacb: 74 23 je 10aaf0 <_IO_Manager_initialization+0x64> <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 10aacd: 8b 1d 24 02 12 00 mov 0x120224,%ebx <== NOT EXECUTED 10aad3: 31 d2 xor %edx,%edx <== NOT EXECUTED 10aad5: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aad7: 90 nop <== NOT EXECUTED 10aad8: 8d 3c 03 lea (%ebx,%eax,1),%edi <== NOT EXECUTED 10aadb: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10aade: 01 c6 add %eax,%esi <== NOT EXECUTED 10aae0: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10aae5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 10aae7: 42 inc %edx <== NOT EXECUTED 10aae8: 83 c0 18 add $0x18,%eax <== NOT EXECUTED 10aaeb: 39 55 0c cmp %edx,0xc(%ebp) <== NOT EXECUTED 10aaee: 77 e8 ja 10aad8 <_IO_Manager_initialization+0x4c> <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; number_of_drivers = drivers_in_table; } 10aaf0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aaf3: 5b pop %ebx <== NOT EXECUTED 10aaf4: 5e pop %esi <== NOT EXECUTED 10aaf5: 5f pop %edi <== NOT EXECUTED 10aaf6: c9 leave <== NOT EXECUTED 10aaf7: c3 ret <== NOT EXECUTED * 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; 10aaf8: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10aafb: a3 24 02 12 00 mov %eax,0x120224 <== NOT EXECUTED _IO_Number_of_drivers = number_of_drivers; 10ab00: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10ab03: 89 0d 20 02 12 00 mov %ecx,0x120220 <== NOT EXECUTED ); for ( index = 0 ; index < drivers_in_table ; index++ ) _IO_Driver_address_table[index] = driver_table[index]; number_of_drivers = drivers_in_table; } 10ab09: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ab0c: 5b pop %ebx <== NOT EXECUTED 10ab0d: 5e pop %esi <== NOT EXECUTED 10ab0e: 5f pop %edi <== NOT EXECUTED 10ab0f: c9 leave <== NOT EXECUTED 10ab10: c3 ret <== NOT EXECUTED 0010b5c0 <_ISR_Handler_initialization>: * * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { 10b5c0: 55 push %ebp <== NOT EXECUTED 10b5c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b5c3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED _ISR_Signals_to_thread_executing = FALSE; 10b5c6: c6 05 28 f9 11 00 00 movb $0x0,0x11f928 <== NOT EXECUTED _ISR_Nest_level = 0; 10b5cd: c7 05 58 f8 11 00 00 movl $0x0,0x11f858 <== NOT EXECUTED 10b5d4: 00 00 00 <== NOT EXECUTED _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( !_Stack_Is_enough(_Configuration_Table->interrupt_stack_size) ) 10b5d7: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10b5dc: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10b5df: 3b 05 d0 b1 11 00 cmp 0x11b1d0,%eax <== NOT EXECUTED 10b5e5: 72 21 jb 10b608 <_ISR_Handler_initialization+0x48> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL ); _CPU_Interrupt_stack_low = _Workspace_Allocate_or_fatal_error( 10b5e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b5ea: 50 push %eax <== NOT EXECUTED 10b5eb: e8 a8 1e 00 00 call 10d498 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b5f0: a3 c8 f7 11 00 mov %eax,0x11f7c8 <== NOT EXECUTED _Configuration_Table->interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 10b5f5: 8b 15 54 f8 11 00 mov 0x11f854,%edx <== NOT EXECUTED 10b5fb: 03 42 1c add 0x1c(%edx),%eax <== NOT EXECUTED 10b5fe: a3 88 f7 11 00 mov %eax,0x11f788 <== NOT EXECUTED 10b603: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 10b606: c9 leave <== NOT EXECUTED 10b607: c3 ret <== NOT EXECUTED _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( !_Stack_Is_enough(_Configuration_Table->interrupt_stack_size) ) _Internal_error_Occurred( 10b608: 50 push %eax <== NOT EXECUTED 10b609: 6a 05 push $0x5 <== NOT EXECUTED 10b60b: 6a 01 push $0x1 <== NOT EXECUTED 10b60d: 6a 00 push $0x0 <== NOT EXECUTED 10b60f: e8 6c ff ff ff call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 0010b580 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10b580: 55 push %ebp <== NOT EXECUTED 10b581: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b583: 53 push %ebx <== NOT EXECUTED 10b584: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b587: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b58a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b58d: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED _Internal_errors_What_happened.the_source = the_source; 10b590: 89 15 64 f8 11 00 mov %edx,0x11f864 <== NOT EXECUTED _Internal_errors_What_happened.is_internal = is_internal; 10b596: a2 68 f8 11 00 mov %al,0x11f868 <== NOT EXECUTED _Internal_errors_What_happened.the_error = the_error; 10b59b: 89 1d 6c f8 11 00 mov %ebx,0x11f86c <== NOT EXECUTED _User_extensions_Fatal( the_source, is_internal, the_error ); 10b5a1: 53 push %ebx <== NOT EXECUTED 10b5a2: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10b5a5: 50 push %eax <== NOT EXECUTED 10b5a6: 52 push %edx <== NOT EXECUTED 10b5a7: e8 60 1b 00 00 call 10d10c <_User_extensions_Fatal> <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10b5ac: c7 05 84 f9 11 00 05 movl $0x5,0x11f984 <== NOT EXECUTED 10b5b3: 00 00 00 <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10b5b6: fa cli <== NOT EXECUTED 10b5b7: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b5b9: f4 hlt <== NOT EXECUTED 10b5ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b5bd: eb fe jmp 10b5bd <_Internal_error_Occurred+0x3d> <== NOT EXECUTED 0010f2e8 <_Interrupt_Manager_initialization>: * * Output parameters: NONE */ void _Interrupt_Manager_initialization( void ) { 10f2e8: 55 push %ebp <== NOT EXECUTED 10f2e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED } 10f2eb: c9 leave <== NOT EXECUTED 10f2ec: c3 ret <== NOT EXECUTED 001260b0 <_Message_queue_Allocate>: * Output parameters: * the_message_queue - set if successful, NULL otherwise */ Message_queue_Control *_Message_queue_Allocate(void) { 1260b0: 55 push %ebp <== NOT EXECUTED 1260b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1260b3: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED return (Message_queue_Control *) 1260b6: 68 40 2a 16 00 push $0x162a40 <== NOT EXECUTED 1260bb: e8 d0 a7 fe ff call 110890 <_Objects_Allocate> <== NOT EXECUTED _Objects_Allocate(&_Message_queue_Information); } 1260c0: c9 leave <== NOT EXECUTED 1260c1: c3 ret <== NOT EXECUTED 0010f2f0 <_Message_queue_Manager_initialization>: */ void _Message_queue_Manager_initialization( uint32_t maximum_message_queues ) { 10f2f0: 55 push %ebp <== NOT EXECUTED 10f2f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f2f3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f2f6: 6a 04 push $0x4 <== NOT EXECUTED 10f2f8: 6a 00 push $0x0 <== NOT EXECUTED 10f2fa: 68 88 00 00 00 push $0x88 <== NOT EXECUTED 10f2ff: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f302: 6a 04 push $0x4 <== NOT EXECUTED 10f304: 6a 02 push $0x2 <== NOT EXECUTED 10f306: 68 a0 01 12 00 push $0x1201a0 <== NOT EXECUTED 10f30b: e8 5c c8 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f310: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_MESSAGE_QUEUE, _Message_queue_MP_Process_packet ); #endif } 10f313: c9 leave <== NOT EXECUTED 10f314: c3 ret <== NOT EXECUTED 0010a11c <_Message_queue_Translate_core_message_queue_return_code>: }; rtems_status_code _Message_queue_Translate_core_message_queue_return_code ( uint32_t status ) { 10a11c: 55 push %ebp <== NOT EXECUTED 10a11d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a11f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a122: 8b 04 85 54 d5 11 00 mov 0x11d554(,%eax,4),%eax <== NOT EXECUTED if ( status > CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ) return RTEMS_INTERNAL_ERROR; #endif return _Message_queue_Translate_core_return_code_[status]; } 10a129: c9 leave <== NOT EXECUTED 10a12a: c3 ret <== NOT EXECUTED 0010fb30 <_Objects_API_maximum_class>: #include int _Objects_API_maximum_class( uint32_t api ) { 10fb30: 55 push %ebp <== NOT EXECUTED 10fb31: 89 e5 mov %esp,%ebp <== NOT EXECUTED switch (api) { 10fb33: 83 7d 08 02 cmpl $0x2,0x8(%ebp) <== NOT EXECUTED 10fb37: 74 2f je 10fb68 <_Objects_API_maximum_class+0x38> <== NOT EXECUTED 10fb39: 76 15 jbe 10fb50 <_Objects_API_maximum_class+0x20> <== NOT EXECUTED 10fb3b: 83 7d 08 03 cmpl $0x3,0x8(%ebp) <== NOT EXECUTED 10fb3f: 74 1f je 10fb60 <_Objects_API_maximum_class+0x30> <== NOT EXECUTED 10fb41: 83 7d 08 04 cmpl $0x4,0x8(%ebp) <== NOT EXECUTED 10fb45: 75 0f jne 10fb56 <_Objects_API_maximum_class+0x26> <== NOT EXECUTED case OBJECTS_INTERNAL_API: return OBJECTS_INTERNAL_CLASSES_LAST; case OBJECTS_CLASSIC_API: return OBJECTS_RTEMS_CLASSES_LAST; case OBJECTS_POSIX_API: return OBJECTS_POSIX_CLASSES_LAST; 10fb47: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10fb4c: c9 leave <== NOT EXECUTED 10fb4d: c3 ret <== NOT EXECUTED 10fb4e: 66 90 xchg %ax,%ax <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10fb50: 83 7d 08 01 cmpl $0x1,0x8(%ebp) <== NOT EXECUTED 10fb54: 74 1a je 10fb70 <_Objects_API_maximum_class+0x40> <== NOT EXECUTED case OBJECTS_CLASSIC_API: return OBJECTS_RTEMS_CLASSES_LAST; case OBJECTS_POSIX_API: return OBJECTS_POSIX_CLASSES_LAST; case OBJECTS_ITRON_API: return OBJECTS_ITRON_CLASSES_LAST; 10fb56: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10fb5b: c9 leave <== NOT EXECUTED 10fb5c: c3 ret <== NOT EXECUTED 10fb5d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10fb60: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10fb65: c9 leave <== NOT EXECUTED 10fb66: c3 ret <== NOT EXECUTED 10fb67: 90 nop <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10fb68: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10fb6d: c9 leave <== NOT EXECUTED 10fb6e: c3 ret <== NOT EXECUTED 10fb6f: 90 nop <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10fb70: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10fb75: c9 leave <== NOT EXECUTED 10fb76: c3 ret <== NOT EXECUTED 0010b614 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10b614: 55 push %ebp <== NOT EXECUTED 10b615: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b617: 56 push %esi <== NOT EXECUTED 10b618: 53 push %ebx <== NOT EXECUTED 10b619: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED * If the application is using the optional manager stubs and * still attempts to create the object, the information block * should be all zeroed out because it is in the BSS. So let's * check that code for this manager is even present. */ if ( information->size == 0 ) 10b61c: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10b61f: 85 c0 test %eax,%eax <== NOT EXECUTED 10b621: 75 0d jne 10b630 <_Objects_Allocate+0x1c> <== NOT EXECUTED 10b623: 31 c9 xor %ecx,%ecx <== NOT EXECUTED information->inactive--; } } return the_object; } 10b625: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b627: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b62a: 5b pop %ebx <== NOT EXECUTED 10b62b: 5e pop %esi <== NOT EXECUTED 10b62c: c9 leave <== NOT EXECUTED 10b62d: c3 ret <== NOT EXECUTED 10b62e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * OK. The manager should be initialized and configured to have objects. * With any luck, it is safe to attempt to allocate an object. */ the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10b630: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED 10b633: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b636: 56 push %esi <== NOT EXECUTED 10b637: e8 c4 f7 ff ff call 10ae00 <_Chain_Get> <== NOT EXECUTED 10b63c: 89 c1 mov %eax,%ecx <== NOT EXECUTED if ( information->auto_extend ) { 10b63e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b641: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10b645: 74 de je 10b625 <_Objects_Allocate+0x11> <== NOT EXECUTED /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10b647: 85 c0 test %eax,%eax <== NOT EXECUTED 10b649: 74 2d je 10b678 <_Objects_Allocate+0x64> <== NOT EXECUTED } if ( the_object ) { uint32_t block; block = _Objects_Get_index( the_object->id ) - 10b64b: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10b64e: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10b653: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10b656: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10b65c: 29 d0 sub %edx,%eax <== NOT EXECUTED _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 10b65e: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b660: f7 73 14 divl 0x14(%ebx) <== NOT EXECUTED 10b663: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b666: 03 43 30 add 0x30(%ebx),%eax <== NOT EXECUTED 10b669: ff 08 decl (%eax) <== NOT EXECUTED information->inactive--; 10b66b: 66 ff 4b 2c decw 0x2c(%ebx) <== NOT EXECUTED } } return the_object; } 10b66f: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b671: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b674: 5b pop %ebx <== NOT EXECUTED 10b675: 5e pop %esi <== NOT EXECUTED 10b676: c9 leave <== NOT EXECUTED 10b677: c3 ret <== NOT EXECUTED * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { _Objects_Extend_information( information ); 10b678: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b67b: 53 push %ebx <== NOT EXECUTED 10b67c: e8 37 00 00 00 call 10b6b8 <_Objects_Extend_information> <== NOT EXECUTED the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10b681: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10b684: e8 77 f7 ff ff call 10ae00 <_Chain_Get> <== NOT EXECUTED 10b689: 89 c1 mov %eax,%ecx <== NOT EXECUTED } if ( the_object ) { 10b68b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b68e: 85 c0 test %eax,%eax <== NOT EXECUTED 10b690: 74 93 je 10b625 <_Objects_Allocate+0x11> <== NOT EXECUTED 10b692: eb b7 jmp 10b64b <_Objects_Allocate+0x37> <== NOT EXECUTED 0010b694 <_Objects_Close>: void _Objects_Close( Objects_Information *information, Objects_Control *the_object ) { 10b694: 55 push %ebp <== NOT EXECUTED 10b695: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b697: 53 push %ebx <== NOT EXECUTED 10b698: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b69b: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10b69e: 0f b7 51 08 movzwl 0x8(%ecx),%edx <== NOT EXECUTED 10b6a2: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10b6a5: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) <== NOT EXECUTED _Objects_Invalidate_Id( information, the_object ); _Objects_Namespace_remove( information, the_object ); 10b6ac: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED } 10b6af: 5b pop %ebx <== NOT EXECUTED 10b6b0: c9 leave <== NOT EXECUTED Objects_Control *the_object ) { _Objects_Invalidate_Id( information, the_object ); _Objects_Namespace_remove( information, the_object ); 10b6b1: e9 76 05 00 00 jmp 10bc2c <_Objects_Namespace_remove> <== NOT EXECUTED 0010b6b8 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 10b6b8: 55 push %ebp <== NOT EXECUTED 10b6b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b6bb: 57 push %edi <== NOT EXECUTED 10b6bc: 56 push %esi <== NOT EXECUTED 10b6bd: 53 push %ebx <== NOT EXECUTED 10b6be: 83 ec 5c sub $0x5c,%esp <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 10b6c1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b6c4: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10b6c7: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10b6cc: 89 45 c8 mov %eax,-0x38(%ebp) <== NOT EXECUTED minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; if ( information->maximum < minimum_index ) 10b6cf: 0f b7 72 10 movzwl 0x10(%edx),%esi <== NOT EXECUTED 10b6d3: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10b6d5: 0f 83 e9 01 00 00 jae 10b8c4 <_Objects_Extend_information+0x20c> <== NOT EXECUTED 10b6db: 8b 4a 14 mov 0x14(%edx),%ecx <== NOT EXECUTED 10b6de: 89 4d a8 mov %ecx,-0x58(%ebp) <== NOT EXECUTED 10b6e1: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED 10b6e4: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp) <== NOT EXECUTED 10b6eb: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b6ed: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) <== NOT EXECUTED 10b6f4: ba 03 00 00 00 mov $0x3,%edx <== NOT EXECUTED * Up the block count and maximum */ block_count++; maximum = information->maximum + information->allocation_size; 10b6f9: 03 75 a8 add -0x58(%ebp),%esi <== NOT EXECUTED 10b6fc: 89 75 d4 mov %esi,-0x2c(%ebp) <== NOT EXECUTED /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 10b6ff: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b702: 80 78 12 00 cmpb $0x0,0x12(%eax) <== NOT EXECUTED 10b706: 0f 85 1c 02 00 00 jne 10b928 <_Objects_Extend_information+0x270> <== NOT EXECUTED if ( !object_blocks ) return; } else { object_blocks = (void**) 10b70c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b70f: 8b 75 c8 mov -0x38(%ebp),%esi <== NOT EXECUTED 10b712: 8d 04 32 lea (%edx,%esi,1),%eax <== NOT EXECUTED 10b715: 03 45 d4 add -0x2c(%ebp),%eax <== NOT EXECUTED 10b718: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b71b: 50 push %eax <== NOT EXECUTED 10b71c: e8 77 1d 00 00 call 10d498 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b721: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED 10b724: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 10b727: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED 10b72a: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10b72d: 8d 3c b8 lea (%eax,%edi,4),%edi <== NOT EXECUTED 10b730: 89 7d d0 mov %edi,-0x30(%ebp) <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 10b733: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 10b736: 8d 14 d0 lea (%eax,%edx,8),%edx <== NOT EXECUTED 10b739: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 10b73c: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b73f: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 10b743: 3b 45 c8 cmp -0x38(%ebp),%eax <== NOT EXECUTED 10b746: 0f 87 38 02 00 00 ja 10b984 <_Objects_Extend_information+0x2cc> <== NOT EXECUTED else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10b74c: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 10b74f: 85 c0 test %eax,%eax <== NOT EXECUTED 10b751: 74 15 je 10b768 <_Objects_Extend_information+0xb0> <== NOT EXECUTED information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10b753: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b755: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { local_table[ index ] = NULL; 10b758: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 10b75b: c7 04 82 00 00 00 00 movl $0x0,(%edx,%eax,4) <== NOT EXECUTED else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10b762: 40 inc %eax <== NOT EXECUTED 10b763: 3b 45 c8 cmp -0x38(%ebp),%eax <== NOT EXECUTED 10b766: 72 f0 jb 10b758 <_Objects_Extend_information+0xa0> <== NOT EXECUTED /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 10b768: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 10b76b: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b76e: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED 10b771: c7 04 01 00 00 00 00 movl $0x0,(%ecx,%eax,1) <== NOT EXECUTED inactive_per_block[block_count] = 0; 10b778: 8b 75 d0 mov -0x30(%ebp),%esi <== NOT EXECUTED 10b77b: c7 04 06 00 00 00 00 movl $0x0,(%esi,%eax,1) <== NOT EXECUTED for ( index=index_base ; index < ( information->allocation_size + index_base ); 10b782: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED 10b785: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b788: 03 4f 14 add 0x14(%edi),%ecx <== NOT EXECUTED 10b78b: 39 4d c4 cmp %ecx,-0x3c(%ebp) <== NOT EXECUTED 10b78e: 73 1a jae 10b7aa <_Objects_Extend_information+0xf2> <== NOT EXECUTED 10b790: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED 10b793: 8b 75 d8 mov -0x28(%ebp),%esi <== NOT EXECUTED 10b796: 8d 14 86 lea (%esi,%eax,4),%edx <== NOT EXECUTED 10b799: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED index++ ) { local_table[ index ] = NULL; 10b79c: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 10b7a2: 40 inc %eax <== NOT EXECUTED 10b7a3: 83 c2 04 add $0x4,%edx <== NOT EXECUTED object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); 10b7a6: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10b7a8: 72 f2 jb 10b79c <_Objects_Extend_information+0xe4> <== NOT EXECUTED index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 10b7aa: 9c pushf <== NOT EXECUTED 10b7ab: fa cli <== NOT EXECUTED 10b7ac: 59 pop %ecx <== NOT EXECUTED old_tables = information->object_blocks; 10b7ad: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b7b0: 8b 77 34 mov 0x34(%edi),%esi <== NOT EXECUTED information->object_blocks = object_blocks; 10b7b3: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10b7b6: 89 47 34 mov %eax,0x34(%edi) <== NOT EXECUTED information->inactive_per_block = inactive_per_block; 10b7b9: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 10b7bc: 89 57 30 mov %edx,0x30(%edi) <== NOT EXECUTED information->local_table = local_table; 10b7bf: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 10b7c2: 89 47 1c mov %eax,0x1c(%edi) <== NOT EXECUTED information->maximum = maximum; 10b7c5: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 10b7c8: 66 89 57 10 mov %dx,0x10(%edi) <== NOT EXECUTED information->maximum_id = _Objects_Build_id( 10b7cc: 8b 17 mov (%edi),%edx <== NOT EXECUTED 10b7ce: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10b7d1: 81 ca 00 00 01 00 or $0x10000,%edx <== NOT EXECUTED 10b7d7: 0f b7 47 04 movzwl 0x4(%edi),%eax <== NOT EXECUTED 10b7db: c1 e0 1b shl $0x1b,%eax <== NOT EXECUTED 10b7de: 09 c2 or %eax,%edx <== NOT EXECUTED 10b7e0: 0f b7 45 d4 movzwl -0x2c(%ebp),%eax <== NOT EXECUTED 10b7e4: 09 c2 or %eax,%edx <== NOT EXECUTED 10b7e6: 89 57 0c mov %edx,0xc(%edi) <== NOT EXECUTED information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 10b7e9: 51 push %ecx <== NOT EXECUTED 10b7ea: 9d popf <== NOT EXECUTED if ( old_tables ) 10b7eb: 85 f6 test %esi,%esi <== NOT EXECUTED 10b7ed: 0f 84 c9 01 00 00 je 10b9bc <_Objects_Extend_information+0x304> <== NOT EXECUTED _Workspace_Free( old_tables ); 10b7f3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b7f6: 56 push %esi <== NOT EXECUTED 10b7f7: e8 6c 1c 00 00 call 10d468 <_Workspace_Free> <== NOT EXECUTED 10b7fc: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b7ff: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED 10b802: 89 75 a8 mov %esi,-0x58(%ebp) <== NOT EXECUTED 10b805: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 10b808: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b80b: 80 7f 12 00 cmpb $0x0,0x12(%edi) <== NOT EXECUTED 10b80f: 0f 84 3b 01 00 00 je 10b950 <_Objects_Extend_information+0x298> <== NOT EXECUTED information->object_blocks[ block ] = 10b815: c1 e3 02 shl $0x2,%ebx <== NOT EXECUTED 10b818: 89 5d dc mov %ebx,-0x24(%ebp) <== NOT EXECUTED 10b81b: 03 5f 34 add 0x34(%edi),%ebx <== NOT EXECUTED 10b81e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b821: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 10b824: 0f af 47 18 imul 0x18(%edi),%eax <== NOT EXECUTED 10b828: 50 push %eax <== NOT EXECUTED 10b829: e8 52 1c 00 00 call 10d480 <_Workspace_Allocate> <== NOT EXECUTED 10b82e: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Workspace_Allocate( (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 10b830: 8b 47 34 mov 0x34(%edi),%eax <== NOT EXECUTED 10b833: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10b836: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10b839: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b83c: 85 c0 test %eax,%eax <== NOT EXECUTED 10b83e: 74 7a je 10b8ba <_Objects_Extend_information+0x202> <== NOT EXECUTED /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 10b840: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b843: ff 71 18 pushl 0x18(%ecx) <== NOT EXECUTED 10b846: ff 71 14 pushl 0x14(%ecx) <== NOT EXECUTED 10b849: 50 push %eax <== NOT EXECUTED 10b84a: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 10b84d: 56 push %esi <== NOT EXECUTED 10b84e: e8 7d 3e 00 00 call 10f6d0 <_Chain_Initialize> <== NOT EXECUTED information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10b853: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b856: 83 c6 20 add $0x20,%esi <== NOT EXECUTED 10b859: 8b 5d c4 mov -0x3c(%ebp),%ebx <== NOT EXECUTED 10b85c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b85f: eb 2c jmp 10b88d <_Objects_Extend_information+0x1d5> <== NOT EXECUTED 10b861: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 10b864: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b867: 8b 07 mov (%edi),%eax <== NOT EXECUTED 10b869: c1 e0 18 shl $0x18,%eax <== NOT EXECUTED 10b86c: 0d 00 00 01 00 or $0x10000,%eax <== NOT EXECUTED 10b871: 0f b7 57 04 movzwl 0x4(%edi),%edx <== NOT EXECUTED 10b875: c1 e2 1b shl $0x1b,%edx <== NOT EXECUTED 10b878: 09 d0 or %edx,%eax <== NOT EXECUTED 10b87a: 09 d8 or %ebx,%eax <== NOT EXECUTED 10b87c: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10b87f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b882: 51 push %ecx <== NOT EXECUTED 10b883: 56 push %esi <== NOT EXECUTED 10b884: e8 53 f5 ff ff call 10addc <_Chain_Append> <== NOT EXECUTED index++; 10b889: 43 inc %ebx <== NOT EXECUTED 10b88a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { 10b88d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b890: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10b893: 50 push %eax <== NOT EXECUTED 10b894: e8 67 f5 ff ff call 10ae00 <_Chain_Get> <== NOT EXECUTED 10b899: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b89b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b89e: 85 c0 test %eax,%eax <== NOT EXECUTED 10b8a0: 75 c2 jne 10b864 <_Objects_Extend_information+0x1ac> <== NOT EXECUTED _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 10b8a2: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b8a5: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10b8a8: 89 d1 mov %edx,%ecx <== NOT EXECUTED 10b8aa: 8b 52 14 mov 0x14(%edx),%edx <== NOT EXECUTED 10b8ad: 8b 75 dc mov -0x24(%ebp),%esi <== NOT EXECUTED 10b8b0: 89 14 30 mov %edx,(%eax,%esi,1) <== NOT EXECUTED information->inactive += information->allocation_size; 10b8b3: 8b 41 14 mov 0x14(%ecx),%eax <== NOT EXECUTED 10b8b6: 66 01 41 2c add %ax,0x2c(%ecx) <== NOT EXECUTED } 10b8ba: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b8bd: 5b pop %ebx <== NOT EXECUTED 10b8be: 5e pop %esi <== NOT EXECUTED 10b8bf: 5f pop %edi <== NOT EXECUTED 10b8c0: c9 leave <== NOT EXECUTED 10b8c1: c3 ret <== NOT EXECUTED 10b8c2: 66 90 xchg %ax,%ax <== NOT EXECUTED block = 0; if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; 10b8c4: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b8c7: 8b 7f 14 mov 0x14(%edi),%edi <== NOT EXECUTED 10b8ca: 89 7d a8 mov %edi,-0x58(%ebp) <== NOT EXECUTED 10b8cd: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b8cf: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b8d1: f7 f7 div %edi <== NOT EXECUTED 10b8d3: 89 45 a4 mov %eax,-0x5c(%ebp) <== NOT EXECUTED 10b8d6: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED for ( ; block < block_count; block++ ) { 10b8d9: 85 c0 test %eax,%eax <== NOT EXECUTED 10b8db: 0f 84 e6 00 00 00 je 10b9c7 <_Objects_Extend_information+0x30f> <== NOT EXECUTED if ( information->object_blocks[ block ] == NULL ) 10b8e1: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b8e4: 8b 4f 34 mov 0x34(%edi),%ecx <== NOT EXECUTED 10b8e7: 8b 19 mov (%ecx),%ebx <== NOT EXECUTED 10b8e9: 85 db test %ebx,%ebx <== NOT EXECUTED 10b8eb: 0f 84 d6 00 00 00 je 10b9c7 <_Objects_Extend_information+0x30f> <== NOT EXECUTED 10b8f1: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 10b8f4: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED 10b8f7: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b8f9: eb 08 jmp 10b903 <_Objects_Extend_information+0x24b> <== NOT EXECUTED 10b8fb: 90 nop <== NOT EXECUTED 10b8fc: 8b 14 99 mov (%ecx,%ebx,4),%edx <== NOT EXECUTED 10b8ff: 85 d2 test %edx,%edx <== NOT EXECUTED 10b901: 74 0c je 10b90f <_Objects_Extend_information+0x257> <== NOT EXECUTED break; else index_base += information->allocation_size; 10b903: 8b 55 a8 mov -0x58(%ebp),%edx <== NOT EXECUTED 10b906: 01 55 c4 add %edx,-0x3c(%ebp) <== NOT EXECUTED if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10b909: 43 inc %ebx <== NOT EXECUTED 10b90a: 39 5d a4 cmp %ebx,-0x5c(%ebp) <== NOT EXECUTED 10b90d: 77 ed ja 10b8fc <_Objects_Extend_information+0x244> <== NOT EXECUTED /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 10b90f: 39 75 c4 cmp %esi,-0x3c(%ebp) <== NOT EXECUTED 10b912: 0f 82 f0 fe ff ff jb 10b808 <_Objects_Extend_information+0x150> <== NOT EXECUTED 10b918: 8b 7d a4 mov -0x5c(%ebp),%edi <== NOT EXECUTED 10b91b: 47 inc %edi <== NOT EXECUTED 10b91c: 89 7d e0 mov %edi,-0x20(%ebp) <== NOT EXECUTED 10b91f: 8d 14 7f lea (%edi,%edi,2),%edx <== NOT EXECUTED 10b922: e9 d2 fd ff ff jmp 10b6f9 <_Objects_Extend_information+0x41> <== NOT EXECUTED 10b927: 90 nop <== NOT EXECUTED /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { object_blocks = (void**) 10b928: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b92b: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 10b92e: 8d 04 0a lea (%edx,%ecx,1),%eax <== NOT EXECUTED 10b931: 01 f0 add %esi,%eax <== NOT EXECUTED 10b933: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b936: 50 push %eax <== NOT EXECUTED 10b937: e8 44 1b 00 00 call 10d480 <_Workspace_Allocate> <== NOT EXECUTED 10b93c: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)) ); if ( !object_blocks ) 10b93f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b942: 85 c0 test %eax,%eax <== NOT EXECUTED 10b944: 0f 85 dd fd ff ff jne 10b727 <_Objects_Extend_information+0x6f> <== NOT EXECUTED 10b94a: e9 6b ff ff ff jmp 10b8ba <_Objects_Extend_information+0x202> <== NOT EXECUTED 10b94f: 90 nop <== NOT EXECUTED if ( !information->object_blocks[ block ] ) return; } else { information->object_blocks[ block ] = 10b950: c1 e3 02 shl $0x2,%ebx <== NOT EXECUTED 10b953: 89 5d dc mov %ebx,-0x24(%ebp) <== NOT EXECUTED 10b956: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b959: 03 59 34 add 0x34(%ecx),%ebx <== NOT EXECUTED 10b95c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b95f: 8b 75 a8 mov -0x58(%ebp),%esi <== NOT EXECUTED 10b962: 0f af 71 18 imul 0x18(%ecx),%esi <== NOT EXECUTED 10b966: 56 push %esi <== NOT EXECUTED 10b967: e8 2c 1b 00 00 call 10d498 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b96c: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10b96e: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b971: 8b 47 34 mov 0x34(%edi),%eax <== NOT EXECUTED 10b974: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10b977: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10b97a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b97d: e9 be fe ff ff jmp 10b840 <_Objects_Extend_information+0x188> <== NOT EXECUTED 10b982: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * 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, 10b984: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 10b987: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b98a: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b98d: 8b 77 34 mov 0x34(%edi),%esi <== NOT EXECUTED 10b990: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED 10b993: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b995: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 10b997: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b99a: 8b 72 30 mov 0x30(%edx),%esi <== NOT EXECUTED 10b99d: 8b 7d d0 mov -0x30(%ebp),%edi <== NOT EXECUTED 10b9a0: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b9a2: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10b9a4: 0f b7 4a 10 movzwl 0x10(%edx),%ecx <== NOT EXECUTED 10b9a8: 03 4d c8 add -0x38(%ebp),%ecx <== NOT EXECUTED 10b9ab: c1 e1 02 shl $0x2,%ecx <== NOT EXECUTED 10b9ae: 8b 72 1c mov 0x1c(%edx),%esi <== NOT EXECUTED 10b9b1: 8b 7d d8 mov -0x28(%ebp),%edi <== NOT EXECUTED 10b9b4: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10b9b6: e9 ad fd ff ff jmp 10b768 <_Objects_Extend_information+0xb0> <== NOT EXECUTED 10b9bb: 90 nop <== NOT EXECUTED information->maximum ); _ISR_Enable( level ); if ( old_tables ) 10b9bc: 8b 4f 14 mov 0x14(%edi),%ecx <== NOT EXECUTED 10b9bf: 89 4d a8 mov %ecx,-0x58(%ebp) <== NOT EXECUTED 10b9c2: e9 41 fe ff ff jmp 10b808 <_Objects_Extend_information+0x150> <== NOT EXECUTED if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10b9c7: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 10b9ca: 89 4d c4 mov %ecx,-0x3c(%ebp) <== NOT EXECUTED 10b9cd: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b9cf: e9 3b ff ff ff jmp 10b90f <_Objects_Extend_information+0x257> <== NOT EXECUTED 0010b9d4 <_Objects_Free>: void _Objects_Free( Objects_Information *information, Objects_Control *the_object ) { 10b9d4: 55 push %ebp <== NOT EXECUTED 10b9d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b9d7: 57 push %edi <== NOT EXECUTED 10b9d8: 56 push %esi <== NOT EXECUTED 10b9d9: 53 push %ebx <== NOT EXECUTED 10b9da: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10b9dd: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b9e0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED uint32_t allocation_size = information->allocation_size; 10b9e3: 8b 7b 14 mov 0x14(%ebx),%edi <== NOT EXECUTED _Chain_Append( &information->Inactive, &the_object->Node ); 10b9e6: 56 push %esi <== NOT EXECUTED 10b9e7: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED 10b9ea: 50 push %eax <== NOT EXECUTED 10b9eb: e8 ec f3 ff ff call 10addc <_Chain_Append> <== NOT EXECUTED if ( information->auto_extend ) { 10b9f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b9f3: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10b9f7: 74 35 je 10ba2e <_Objects_Free+0x5a> <== NOT EXECUTED uint32_t block; block = 10b9f9: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10b9fc: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10ba01: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10ba04: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10ba0a: 29 d0 sub %edx,%eax <== NOT EXECUTED _Objects_Get_index( the_object->id ) - _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]++; 10ba0c: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ba0e: f7 73 14 divl 0x14(%ebx) <== NOT EXECUTED 10ba11: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10ba14: 03 43 30 add 0x30(%ebx),%eax <== NOT EXECUTED 10ba17: ff 00 incl (%eax) <== NOT EXECUTED information->inactive++; 10ba19: 8b 53 2c mov 0x2c(%ebx),%edx <== NOT EXECUTED 10ba1c: 42 inc %edx <== NOT EXECUTED 10ba1d: 66 89 53 2c mov %dx,0x2c(%ebx) <== NOT EXECUTED /* * Check if the threshold level has been met of * 1.5 x allocation_size are free. */ if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) { 10ba21: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10ba24: 89 f8 mov %edi,%eax <== NOT EXECUTED 10ba26: d1 e8 shr %eax <== NOT EXECUTED 10ba28: 01 f8 add %edi,%eax <== NOT EXECUTED 10ba2a: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10ba2c: 77 0a ja 10ba38 <_Objects_Free+0x64> <== NOT EXECUTED _Objects_Shrink_information( information ); } } } 10ba2e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ba31: 5b pop %ebx <== NOT EXECUTED 10ba32: 5e pop %esi <== NOT EXECUTED 10ba33: 5f pop %edi <== NOT EXECUTED 10ba34: c9 leave <== NOT EXECUTED 10ba35: c3 ret <== NOT EXECUTED 10ba36: 66 90 xchg %ax,%ax <== NOT EXECUTED * Check if the threshold level has been met of * 1.5 x allocation_size are free. */ if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) { _Objects_Shrink_information( information ); 10ba38: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } } 10ba3b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ba3e: 5b pop %ebx <== NOT EXECUTED 10ba3f: 5e pop %esi <== NOT EXECUTED 10ba40: 5f pop %edi <== NOT EXECUTED 10ba41: c9 leave <== NOT EXECUTED * Check if the threshold level has been met of * 1.5 x allocation_size are free. */ if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) { _Objects_Shrink_information( information ); 10ba42: e9 a5 02 00 00 jmp 10bcec <_Objects_Shrink_information> <== NOT EXECUTED 0010bb08 <_Objects_Get>: Objects_Control *_Objects_Get( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 10bb08: 55 push %ebp <== NOT EXECUTED 10bb09: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb0b: 53 push %ebx <== NOT EXECUTED 10bb0c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bb0f: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED * always NULL. * * If the Id is valid but the object has not been created yet, then * the local_table entry will be NULL. */ index = id - information->minimum_id + 1; 10bb12: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10bb17: 2b 51 08 sub 0x8(%ecx),%edx <== NOT EXECUTED 10bb1a: 03 55 0c add 0xc(%ebp),%edx <== NOT EXECUTED /* * If the index is less than maximum, then it is OK to use it to * index into the local_table array. */ if ( index <= information->maximum ) { 10bb1d: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 10bb21: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10bb23: 77 27 ja 10bb4c <_Objects_Get+0x44> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10bb25: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10bb2a: 40 inc %eax <== NOT EXECUTED 10bb2b: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED _Thread_Disable_dispatch(); if ( (the_object = information->local_table[ index ]) != NULL ) { 10bb30: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 10bb33: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED 10bb36: 85 db test %ebx,%ebx <== NOT EXECUTED 10bb38: 74 1f je 10bb59 <_Objects_Get+0x51> <== NOT EXECUTED *location = OBJECTS_LOCAL; 10bb3a: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10bb3d: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10bb43: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bb45: 5a pop %edx <== NOT EXECUTED 10bb46: 5b pop %ebx <== NOT EXECUTED 10bb47: c9 leave <== NOT EXECUTED 10bb48: c3 ret <== NOT EXECUTED 10bb49: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Object Id is not within this API and Class on this node. So * it may be global in a multiprocessing system. But it is clearly * invalid on a single processor system. */ *location = OBJECTS_ERROR; 10bb4c: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10bb4f: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10bb55: 31 db xor %ebx,%ebx <== NOT EXECUTED 10bb57: eb ea jmp 10bb43 <_Objects_Get+0x3b> <== NOT EXECUTED /* * Valid Id for this API, Class and Node but the object has not * been allocated yet. */ _Thread_Enable_dispatch(); 10bb59: e8 ee 07 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED *location = OBJECTS_ERROR; 10bb5e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10bb61: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10bb67: eb da jmp 10bb43 <_Objects_Get+0x3b> <== NOT EXECUTED 0010ba68 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint32_t the_class ) { 10ba68: 55 push %ebp <== NOT EXECUTED 10ba69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ba6b: 53 push %ebx <== NOT EXECUTED 10ba6c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10ba6f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10ba72: 8d 43 ff lea -0x1(%ebx),%eax <== NOT EXECUTED 10ba75: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10ba78: 77 07 ja 10ba81 <_Objects_Get_information+0x19> <== NOT EXECUTED int the_class_api_maximum; if ( !_Objects_Is_api_valid( the_api ) ) return NULL; if ( !the_class ) 10ba7a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ba7d: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba7f: 75 07 jne 10ba88 <_Objects_Get_information+0x20> <== NOT EXECUTED * In a multprocessing configuration, we may access remote objects. * Thus we may have 0 local instances and still have a valid object * pointer. */ #if !defined(RTEMS_MULTIPROCESSING) if ( info->maximum == 0 ) 10ba81: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; #endif return info; } 10ba83: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ba86: c9 leave <== NOT EXECUTED 10ba87: c3 ret <== NOT EXECUTED return NULL; if ( !the_class ) return NULL; the_class_api_maximum = _Objects_API_maximum_class( the_api ); 10ba88: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ba8b: 53 push %ebx <== NOT EXECUTED 10ba8c: e8 9f 40 00 00 call 10fb30 <_Objects_API_maximum_class> <== NOT EXECUTED if ( the_class_api_maximum < 0 || 10ba91: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ba94: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba96: 78 e9 js 10ba81 <_Objects_Get_information+0x19> <== NOT EXECUTED 10ba98: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 10ba9b: 77 e4 ja 10ba81 <_Objects_Get_information+0x19> <== NOT EXECUTED the_class > (uint32_t) the_class_api_maximum ) return NULL; if ( !_Objects_Information_table[ the_api ] ) 10ba9d: 8b 04 9d 8c f7 11 00 mov 0x11f78c(,%ebx,4),%eax <== NOT EXECUTED 10baa4: 85 c0 test %eax,%eax <== NOT EXECUTED 10baa6: 74 d9 je 10ba81 <_Objects_Get_information+0x19> <== NOT EXECUTED return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10baa8: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10baab: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED if ( !info ) 10baae: 85 c0 test %eax,%eax <== NOT EXECUTED 10bab0: 74 d1 je 10ba83 <_Objects_Get_information+0x1b> <== NOT EXECUTED * In a multprocessing configuration, we may access remote objects. * Thus we may have 0 local instances and still have a valid object * pointer. */ #if !defined(RTEMS_MULTIPROCESSING) if ( info->maximum == 0 ) 10bab2: 66 83 78 10 00 cmpw $0x0,0x10(%eax) <== NOT EXECUTED 10bab7: 75 ca jne 10ba83 <_Objects_Get_information+0x1b> <== NOT EXECUTED 10bab9: eb c6 jmp 10ba81 <_Objects_Get_information+0x19> <== NOT EXECUTED 0010ba48 <_Objects_Get_information_id>: #include Objects_Information *_Objects_Get_information_id( Objects_Id id ) { 10ba48: 55 push %ebp <== NOT EXECUTED 10ba49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ba4b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ba4e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED return _Objects_Get_information( 10ba51: 89 c2 mov %eax,%edx <== NOT EXECUTED 10ba53: c1 ea 1b shr $0x1b,%edx <== NOT EXECUTED 10ba56: 52 push %edx <== NOT EXECUTED 10ba57: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10ba5a: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10ba5d: 50 push %eax <== NOT EXECUTED 10ba5e: e8 05 00 00 00 call 10ba68 <_Objects_Get_information> <== NOT EXECUTED _Objects_Get_API( id ), _Objects_Get_class( id ) ); } 10ba63: c9 leave <== NOT EXECUTED 10ba64: c3 ret <== NOT EXECUTED 0010babc <_Objects_Get_isr_disable>: Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 10babc: 55 push %ebp <== NOT EXECUTED 10babd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10babf: 56 push %esi <== NOT EXECUTED 10bac0: 53 push %ebx <== NOT EXECUTED 10bac1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bac4: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) index = id - information->minimum_id + 1; #else /* index = _Objects_Get_index( id ); */ index = id & 0x0000ffff; 10bac7: 0f b7 55 0c movzwl 0xc(%ebp),%edx <== NOT EXECUTED /* This should work but doesn't always :( */ /* index = (uint16_t ) id; */ #endif _ISR_Disable( level ); 10bacb: 9c pushf <== NOT EXECUTED 10bacc: fa cli <== NOT EXECUTED 10bacd: 59 pop %ecx <== NOT EXECUTED if ( information->maximum >= index ) { 10bace: 0f b7 43 10 movzwl 0x10(%ebx),%eax <== NOT EXECUTED 10bad2: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10bad4: 77 1a ja 10baf0 <_Objects_Get_isr_disable+0x34> <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { 10bad6: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10bad9: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED 10badc: 85 c0 test %eax,%eax <== NOT EXECUTED 10bade: 74 1c je 10bafc <_Objects_Get_isr_disable+0x40> <== NOT EXECUTED *location = OBJECTS_LOCAL; 10bae0: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED *level_p = level; 10bae6: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10bae9: 89 0a mov %ecx,(%edx) <== NOT EXECUTED _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10baeb: 5b pop %ebx <== NOT EXECUTED 10baec: 5e pop %esi <== NOT EXECUTED 10baed: c9 leave <== NOT EXECUTED 10baee: c3 ret <== NOT EXECUTED 10baef: 90 nop <== NOT EXECUTED } _ISR_Enable( level ); *location = OBJECTS_ERROR; return NULL; } _ISR_Enable( level ); 10baf0: 51 push %ecx <== NOT EXECUTED 10baf1: 9d popf <== NOT EXECUTED *location = OBJECTS_ERROR; 10baf2: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10baf8: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bafa: eb ef jmp 10baeb <_Objects_Get_isr_disable+0x2f> <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { *location = OBJECTS_LOCAL; *level_p = level; return the_object; } _ISR_Enable( level ); 10bafc: 51 push %ecx <== NOT EXECUTED 10bafd: 9d popf <== NOT EXECUTED *location = OBJECTS_ERROR; 10bafe: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10bb04: eb e5 jmp 10baeb <_Objects_Get_isr_disable+0x2f> <== NOT EXECUTED 00116ad4 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 116ad4: 55 push %ebp <== NOT EXECUTED 116ad5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116ad7: 57 push %edi <== NOT EXECUTED 116ad8: 56 push %esi <== NOT EXECUTED 116ad9: 53 push %ebx <== NOT EXECUTED 116ada: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 116add: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 116ae0: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED char lname[5]; Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) 116ae3: 85 f6 test %esi,%esi <== NOT EXECUTED 116ae5: 75 0d jne 116af4 <_Objects_Get_name_as_string+0x20> <== NOT EXECUTED } } *d = '\0'; _Thread_Enable_dispatch(); return name; 116ae7: 31 db xor %ebx,%ebx <== NOT EXECUTED } return NULL; /* unreachable path */ } 116ae9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 116aeb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116aee: 5b pop %ebx <== NOT EXECUTED 116aef: 5e pop %esi <== NOT EXECUTED 116af0: 5f pop %edi <== NOT EXECUTED 116af1: c9 leave <== NOT EXECUTED 116af2: c3 ret <== NOT EXECUTED 116af3: 90 nop <== NOT EXECUTED Objects_Id tmpId; if ( length == 0 ) return NULL; if ( name == NULL ) 116af4: 85 db test %ebx,%ebx <== NOT EXECUTED 116af6: 74 f1 je 116ae9 <_Objects_Get_name_as_string+0x15> <== NOT EXECUTED return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 116af8: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 116afb: 85 ff test %edi,%edi <== NOT EXECUTED 116afd: 0f 84 8d 00 00 00 je 116b90 <_Objects_Get_name_as_string+0xbc> <== NOT EXECUTED 116b03: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 116b06: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 116b09: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116b0c: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 116b0f: e8 40 9d ff ff call 110854 <_Objects_Get_information_id> <== NOT EXECUTED 116b14: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( !information ) 116b16: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116b19: 85 c0 test %eax,%eax <== NOT EXECUTED 116b1b: 74 ca je 116ae7 <_Objects_Get_name_as_string+0x13> <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, tmpId, &location ); 116b1d: 51 push %ecx <== NOT EXECUTED 116b1e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 116b21: 50 push %eax <== NOT EXECUTED 116b22: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 116b25: 57 push %edi <== NOT EXECUTED 116b26: e8 e9 9d ff ff call 110914 <_Objects_Get> <== NOT EXECUTED switch ( location ) { 116b2b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116b2e: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 116b31: 85 d2 test %edx,%edx <== NOT EXECUTED 116b33: 75 b2 jne 116ae7 <_Objects_Get_name_as_string+0x13> <== NOT EXECUTED case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 116b35: 80 7f 38 00 cmpb $0x0,0x38(%edi) <== NOT EXECUTED 116b39: 74 65 je 116ba0 <_Objects_Get_name_as_string+0xcc> <== NOT EXECUTED s = the_object->name.name_p; 116b3b: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 116b3e: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED lname[ 4 ] = '\0'; s = lname; } d = name; if ( s ) { 116b41: 85 c0 test %eax,%eax <== NOT EXECUTED 116b43: 0f 84 84 00 00 00 je 116bcd <_Objects_Get_name_as_string+0xf9> <== NOT EXECUTED for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 116b49: 4e dec %esi <== NOT EXECUTED 116b4a: 89 75 d8 mov %esi,-0x28(%ebp) <== NOT EXECUTED 116b4d: 74 7e je 116bcd <_Objects_Get_name_as_string+0xf9> <== NOT EXECUTED 116b4f: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 116b52: 8a 08 mov (%eax),%cl <== NOT EXECUTED 116b54: 84 c9 test %cl,%cl <== NOT EXECUTED 116b56: 74 75 je 116bcd <_Objects_Get_name_as_string+0xf9> <== NOT EXECUTED 116b58: 89 df mov %ebx,%edi <== NOT EXECUTED 116b5a: 31 f6 xor %esi,%esi <== NOT EXECUTED 116b5c: eb 0c jmp 116b6a <_Objects_Get_name_as_string+0x96> <== NOT EXECUTED 116b5e: 66 90 xchg %ax,%ax <== NOT EXECUTED 116b60: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 116b63: 8a 0c 30 mov (%eax,%esi,1),%cl <== NOT EXECUTED 116b66: 84 c9 test %cl,%cl <== NOT EXECUTED 116b68: 74 19 je 116b83 <_Objects_Get_name_as_string+0xaf> <== NOT EXECUTED *d = (isprint(*s)) ? *s : '*'; 116b6a: 0f be d1 movsbl %cl,%edx <== NOT EXECUTED 116b6d: a1 28 b4 12 00 mov 0x12b428,%eax <== NOT EXECUTED 116b72: f6 04 10 97 testb $0x97,(%eax,%edx,1) <== NOT EXECUTED 116b76: 75 02 jne 116b7a <_Objects_Get_name_as_string+0xa6> <== NOT EXECUTED 116b78: b1 2a mov $0x2a,%cl <== NOT EXECUTED 116b7a: 88 0f mov %cl,(%edi) <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 116b7c: 46 inc %esi <== NOT EXECUTED 116b7d: 47 inc %edi <== NOT EXECUTED 116b7e: 3b 75 d8 cmp -0x28(%ebp),%esi <== NOT EXECUTED 116b81: 72 dd jb 116b60 <_Objects_Get_name_as_string+0x8c> <== NOT EXECUTED *d = (isprint(*s)) ? *s : '*'; } } *d = '\0'; 116b83: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 116b86: e8 cd a5 ff ff call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 116b8b: e9 59 ff ff ff jmp 116ae9 <_Objects_Get_name_as_string+0x15> <== NOT EXECUTED return NULL; if ( name == NULL ) return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 116b90: a1 7c dd 12 00 mov 0x12dd7c,%eax <== NOT EXECUTED 116b95: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 116b98: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 116b9b: e9 69 ff ff ff jmp 116b09 <_Objects_Get_name_as_string+0x35> <== NOT EXECUTED case OBJECTS_LOCAL: if ( information->is_string ) { s = the_object->name.name_p; } else { uint32_t u32_name = (uint32_t) the_object->name.name_u32; 116ba0: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED lname[ 0 ] = (u32_name >> 24) & 0xff; 116ba3: 89 d0 mov %edx,%eax <== NOT EXECUTED 116ba5: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 116ba8: 88 45 eb mov %al,-0x15(%ebp) <== NOT EXECUTED lname[ 1 ] = (u32_name >> 16) & 0xff; 116bab: 89 d0 mov %edx,%eax <== NOT EXECUTED 116bad: c1 e8 10 shr $0x10,%eax <== NOT EXECUTED 116bb0: 88 45 ec mov %al,-0x14(%ebp) <== NOT EXECUTED lname[ 2 ] = (u32_name >> 8) & 0xff; 116bb3: 89 d0 mov %edx,%eax <== NOT EXECUTED 116bb5: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 116bb8: 88 45 ed mov %al,-0x13(%ebp) <== NOT EXECUTED lname[ 3 ] = (u32_name >> 0) & 0xff; 116bbb: 88 55 ee mov %dl,-0x12(%ebp) <== NOT EXECUTED lname[ 4 ] = '\0'; 116bbe: c6 45 ef 00 movb $0x0,-0x11(%ebp) <== NOT EXECUTED 116bc2: 8d 45 eb lea -0x15(%ebp),%eax <== NOT EXECUTED 116bc5: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 116bc8: e9 7c ff ff ff jmp 116b49 <_Objects_Get_name_as_string+0x75> <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 116bcd: 89 df mov %ebx,%edi <== NOT EXECUTED 116bcf: eb b2 jmp 116b83 <_Objects_Get_name_as_string+0xaf> <== NOT EXECUTED 0011942c <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 11942c: 55 push %ebp <== NOT EXECUTED 11942d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11942f: 57 push %edi <== NOT EXECUTED 119430: 56 push %esi <== NOT EXECUTED 119431: 53 push %ebx <== NOT EXECUTED 119432: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 119435: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 119438: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11943b: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Objects_Control *object; Objects_Id next_id; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) 11943e: 66 85 c0 test %ax,%ax <== NOT EXECUTED 119441: 74 2d je 119470 <_Objects_Get_next+0x44> <== NOT EXECUTED 119443: 89 c3 mov %eax,%ebx <== NOT EXECUTED 119445: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 119448: 66 39 5f 10 cmp %bx,0x10(%edi) <== NOT EXECUTED 11944c: 72 2e jb 11947c <_Objects_Get_next+0x50> <== NOT EXECUTED *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 11944e: 51 push %ecx <== NOT EXECUTED 11944f: 56 push %esi <== NOT EXECUTED 119450: 53 push %ebx <== NOT EXECUTED 119451: 57 push %edi <== NOT EXECUTED 119452: e8 bd 74 ff ff call 110914 <_Objects_Get> <== NOT EXECUTED next_id++; 119457: 43 inc %ebx <== NOT EXECUTED } while (*location_p != OBJECTS_LOCAL); 119458: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11945b: 8b 16 mov (%esi),%edx <== NOT EXECUTED 11945d: 85 d2 test %edx,%edx <== NOT EXECUTED 11945f: 75 e7 jne 119448 <_Objects_Get_next+0x1c> <== NOT EXECUTED *next_id_p = next_id; 119461: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 119464: 89 1a mov %ebx,(%edx) <== NOT EXECUTED return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 119466: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 119469: 5b pop %ebx <== NOT EXECUTED 11946a: 5e pop %esi <== NOT EXECUTED 11946b: 5f pop %edi <== NOT EXECUTED 11946c: c9 leave <== NOT EXECUTED 11946d: c3 ret <== NOT EXECUTED 11946e: 66 90 xchg %ax,%ax <== NOT EXECUTED { Objects_Control *object; Objects_Id next_id; if (_Objects_Get_index(id) == OBJECTS_ID_INITIAL_INDEX) next_id = information->minimum_id; 119470: 8b 5f 08 mov 0x8(%edi),%ebx <== NOT EXECUTED else next_id = id; do { /* walked off end of list? */ if (_Objects_Get_index(next_id) > information->maximum) 119473: 66 39 5f 10 cmp %bx,0x10(%edi) <== NOT EXECUTED 119477: 73 d5 jae 11944e <_Objects_Get_next+0x22> <== NOT EXECUTED 119479: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { *location_p = OBJECTS_ERROR; 11947c: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED *next_id_p = next_id; return object; final: *next_id_p = OBJECTS_ID_FINAL; 119482: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 119485: c7 00 ff ff ff ff movl $0xffffffff,(%eax) <== NOT EXECUTED 11948b: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 11948d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 119490: 5b pop %ebx <== NOT EXECUTED 119491: 5e pop %esi <== NOT EXECUTED 119492: 5f pop %edi <== NOT EXECUTED 119493: c9 leave <== NOT EXECUTED 119494: c3 ret <== NOT EXECUTED 00116c00 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 116c00: 55 push %ebp <== NOT EXECUTED 116c01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116c03: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED /* * You can't just extract the index portion or you can get tricked * by a value between 1 and maximum. */ index = id - information->minimum_id + 1; 116c06: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 116c0b: 2b 51 08 sub 0x8(%ecx),%edx <== NOT EXECUTED 116c0e: 03 55 0c add 0xc(%ebp),%edx <== NOT EXECUTED if ( information->maximum >= index ) { 116c11: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 116c15: 39 c2 cmp %eax,%edx <== NOT EXECUTED 116c17: 77 17 ja 116c30 <_Objects_Get_no_protection+0x30> <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { 116c19: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 116c1c: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED 116c1f: 85 c0 test %eax,%eax <== NOT EXECUTED 116c21: 74 0d je 116c30 <_Objects_Get_no_protection+0x30> <== NOT EXECUTED *location = OBJECTS_LOCAL; 116c23: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 116c26: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; return NULL; } 116c2c: c9 leave <== NOT EXECUTED 116c2d: c3 ret <== NOT EXECUTED 116c2e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; 116c30: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 116c33: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 116c39: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; } 116c3b: c9 leave <== NOT EXECUTED 116c3c: c3 ret <== NOT EXECUTED 0010bce4 <_Objects_Handler_initialization>: uint32_t maximum_nodes, uint32_t maximum_global_objects ) #else void _Objects_Handler_initialization(void) #endif { 10bce4: 55 push %ebp <== NOT EXECUTED 10bce5: 89 e5 mov %esp,%ebp <== NOT EXECUTED node, maximum_nodes, maximum_global_objects ); #endif } 10bce7: c9 leave <== NOT EXECUTED 10bce8: c3 ret <== NOT EXECUTED 0010cb9c <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10cb9c: 55 push %ebp <== NOT EXECUTED 10cb9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb9f: 53 push %ebx <== NOT EXECUTED 10cba0: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10cba3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cba6: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Objects_Id tmpId; Objects_Information *information; Objects_Control *the_object = (Objects_Control *) 0; Objects_Locations ignored_location; if ( !name ) 10cba9: 85 db test %ebx,%ebx <== NOT EXECUTED 10cbab: 74 7b je 10cc28 <_Objects_Id_to_name+0x8c> <== NOT EXECUTED return OBJECTS_INVALID_NAME; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10cbad: 85 c0 test %eax,%eax <== NOT EXECUTED 10cbaf: 74 53 je 10cc04 <_Objects_Id_to_name+0x68> <== NOT EXECUTED 10cbb1: 89 c1 mov %eax,%ecx <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10cbb3: 89 ca mov %ecx,%edx <== NOT EXECUTED 10cbb5: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10cbb8: 83 e2 07 and $0x7,%edx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10cbbb: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10cbbe: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10cbc1: 77 59 ja 10cc1c <_Objects_Id_to_name+0x80> <== NOT EXECUTED the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) 10cbc3: 8b 14 95 2c 27 12 00 mov 0x12272c(,%edx,4),%edx <== NOT EXECUTED 10cbca: 85 d2 test %edx,%edx <== NOT EXECUTED 10cbcc: 74 4e je 10cc1c <_Objects_Id_to_name+0x80> <== NOT EXECUTED return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 10cbce: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10cbd0: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED 10cbd3: 8b 14 82 mov (%edx,%eax,4),%edx <== NOT EXECUTED if ( !information ) 10cbd6: 85 d2 test %edx,%edx <== NOT EXECUTED 10cbd8: 74 42 je 10cc1c <_Objects_Id_to_name+0x80> <== NOT EXECUTED return OBJECTS_INVALID_ID; if ( information->is_string ) 10cbda: 80 7a 38 00 cmpb $0x0,0x38(%edx) <== NOT EXECUTED 10cbde: 75 3c jne 10cc1c <_Objects_Id_to_name+0x80> <== NOT EXECUTED return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &ignored_location ); 10cbe0: 50 push %eax <== NOT EXECUTED 10cbe1: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10cbe4: 50 push %eax <== NOT EXECUTED 10cbe5: 51 push %ecx <== NOT EXECUTED 10cbe6: 52 push %edx <== NOT EXECUTED 10cbe7: e8 4c ff ff ff call 10cb38 <_Objects_Get> <== NOT EXECUTED if ( !the_object ) 10cbec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cbef: 85 c0 test %eax,%eax <== NOT EXECUTED 10cbf1: 74 29 je 10cc1c <_Objects_Id_to_name+0x80> <== NOT EXECUTED return OBJECTS_INVALID_ID; *name = the_object->name; 10cbf3: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10cbf6: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10cbf8: e8 13 08 00 00 call 10d410 <_Thread_Enable_dispatch> <== NOT EXECUTED 10cbfd: 31 c0 xor %eax,%eax <== NOT EXECUTED return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 10cbff: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cc02: c9 leave <== NOT EXECUTED 10cc03: c3 ret <== NOT EXECUTED Objects_Locations ignored_location; if ( !name ) return OBJECTS_INVALID_NAME; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10cc04: a1 1c 28 12 00 mov 0x12281c,%eax <== NOT EXECUTED 10cc09: 8b 48 08 mov 0x8(%eax),%ecx <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10cc0c: 89 ca mov %ecx,%edx <== NOT EXECUTED 10cc0e: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10cc11: 83 e2 07 and $0x7,%edx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10cc14: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10cc17: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10cc1a: 76 a7 jbe 10cbc3 <_Objects_Id_to_name+0x27> <== NOT EXECUTED if ( !the_object ) return OBJECTS_INVALID_ID; *name = the_object->name; _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10cc1c: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 10cc21: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cc24: c9 leave <== NOT EXECUTED 10cc25: c3 ret <== NOT EXECUTED 10cc26: 66 90 xchg %ax,%ax <== NOT EXECUTED Objects_Id tmpId; Objects_Information *information; Objects_Control *the_object = (Objects_Control *) 0; Objects_Locations ignored_location; if ( !name ) 10cc28: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10cc2d: eb f2 jmp 10cc21 <_Objects_Id_to_name+0x85> <== NOT EXECUTED 0010bb6c <_Objects_Initialize_information>: , bool supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 10bb6c: 55 push %ebp <== NOT EXECUTED 10bb6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb6f: 57 push %edi <== NOT EXECUTED 10bb70: 56 push %esi <== NOT EXECUTED 10bb71: 53 push %ebx <== NOT EXECUTED 10bb72: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10bb75: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10bb78: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10bb7b: 8b 75 20 mov 0x20(%ebp),%esi <== NOT EXECUTED 10bb7e: 0f b7 4d 18 movzwl 0x18(%ebp),%ecx <== NOT EXECUTED uint32_t name_length; #if defined(RTEMS_MULTIPROCESSING) uint32_t index; #endif information->the_api = the_api; 10bb82: 89 17 mov %edx,(%edi) <== NOT EXECUTED information->the_class = the_class; 10bb84: 66 89 5f 04 mov %bx,0x4(%edi) <== NOT EXECUTED information->is_string = is_string; 10bb88: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 10bb8b: 88 47 38 mov %al,0x38(%edi) <== NOT EXECUTED information->local_table = 0; information->inactive_per_block = 0; 10bb8e: c7 47 30 00 00 00 00 movl $0x0,0x30(%edi) <== NOT EXECUTED information->object_blocks = 0; 10bb95: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) <== NOT EXECUTED information->inactive = 0; 10bb9c: 66 c7 47 2c 00 00 movw $0x0,0x2c(%edi) <== NOT EXECUTED /* * Set the entry in the object information table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 10bba2: 8b 04 95 8c f7 11 00 mov 0x11f78c(,%edx,4),%eax <== NOT EXECUTED 10bba9: 89 3c 98 mov %edi,(%eax,%ebx,4) <== NOT EXECUTED /* * Set the size of the object */ information->size = size; 10bbac: 89 4f 18 mov %ecx,0x18(%edi) <== NOT EXECUTED /* * Are we operating in unlimited, or auto-extend mode */ information->auto_extend = 10bbaf: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10bbb2: c1 e8 1f shr $0x1f,%eax <== NOT EXECUTED 10bbb5: 88 47 12 mov %al,0x12(%edi) <== NOT EXECUTED (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE; maximum &= ~OBJECTS_UNLIMITED_OBJECTS; 10bbb8: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10bbbb: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx <== NOT EXECUTED /* * The allocation unit is the maximum value */ information->allocation_size = maximum; 10bbc1: 89 4f 14 mov %ecx,0x14(%edi) <== NOT EXECUTED /* * Provide a null local table entry for the case of any empty table. */ information->local_table = &null_local_table; 10bbc4: c7 47 1c 24 f5 11 00 movl $0x11f524,0x1c(%edi) <== NOT EXECUTED */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 10bbcb: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10bbce: 81 ca 00 00 01 00 or $0x10000,%edx <== NOT EXECUTED 10bbd4: c1 e3 1b shl $0x1b,%ebx <== NOT EXECUTED 10bbd7: 09 da or %ebx,%edx <== NOT EXECUTED 10bbd9: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bbdb: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bbdd: 0f 95 c0 setne %al <== NOT EXECUTED 10bbe0: 09 c2 or %eax,%edx <== NOT EXECUTED 10bbe2: 89 57 08 mov %edx,0x8(%edi) <== NOT EXECUTED * Calculate the maximum name length */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) 10bbe5: f7 c6 03 00 00 00 test $0x3,%esi <== NOT EXECUTED 10bbeb: 75 23 jne 10bc10 <_Objects_Initialize_information+0xa4> <== NOT EXECUTED 10bbed: 89 f0 mov %esi,%eax <== NOT EXECUTED name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & ~(OBJECTS_NAME_ALIGNMENT-1); information->name_length = name_length; 10bbef: 66 89 47 3a mov %ax,0x3a(%edi) <== NOT EXECUTED 10bbf3: 8d 47 24 lea 0x24(%edi),%eax <== NOT EXECUTED 10bbf6: 89 47 20 mov %eax,0x20(%edi) <== NOT EXECUTED 10bbf9: c7 47 24 00 00 00 00 movl $0x0,0x24(%edi) <== NOT EXECUTED 10bc00: 8d 47 20 lea 0x20(%edi),%eax <== NOT EXECUTED 10bc03: 89 47 28 mov %eax,0x28(%edi) <== NOT EXECUTED /* * Initialize objects .. if there are any */ if ( maximum ) { 10bc06: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bc08: 75 0e jne 10bc18 <_Objects_Initialize_information+0xac> <== NOT EXECUTED _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10bc0a: 5b pop %ebx <== NOT EXECUTED 10bc0b: 5e pop %esi <== NOT EXECUTED 10bc0c: 5f pop %edi <== NOT EXECUTED 10bc0d: c9 leave <== NOT EXECUTED 10bc0e: c3 ret <== NOT EXECUTED 10bc0f: 90 nop <== NOT EXECUTED */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & 10bc10: 8d 46 04 lea 0x4(%esi),%eax <== NOT EXECUTED 10bc13: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 10bc16: eb d7 jmp 10bbef <_Objects_Initialize_information+0x83> <== NOT EXECUTED /* * Reset the maximum value. It will be updated when the information is * extended. */ information->maximum = 0; 10bc18: 66 c7 47 10 00 00 movw $0x0,0x10(%edi) <== NOT EXECUTED * Always have the maximum size available so the current performance * figures are create are met. If the user moves past the maximum * number then a performance hit is taken. */ _Objects_Extend_information( information ); 10bc1e: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10bc21: 5b pop %ebx <== NOT EXECUTED 10bc22: 5e pop %esi <== NOT EXECUTED 10bc23: 5f pop %edi <== NOT EXECUTED 10bc24: c9 leave <== NOT EXECUTED * Always have the maximum size available so the current performance * figures are create are met. If the user moves past the maximum * number then a performance hit is taken. */ _Objects_Extend_information( information ); 10bc25: e9 8e fa ff ff jmp 10b6b8 <_Objects_Extend_information> <== NOT EXECUTED 001151ec <_Objects_Name_to_id_string>: Objects_Name_or_id_lookup_errors _Objects_Name_to_id_string( Objects_Information *information, const char *name, Objects_Id *id ) { 1151ec: 55 push %ebp <== NOT EXECUTED 1151ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1151ef: 57 push %edi <== NOT EXECUTED 1151f0: 56 push %esi <== NOT EXECUTED 1151f1: 53 push %ebx <== NOT EXECUTED 1151f2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED uint32_t index; uint32_t name_length; /* ASSERT: information->is_string == TRUE */ if ( !id ) 1151f5: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 1151f8: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1151fa: 74 74 je 115270 <_Objects_Name_to_id_string+0x84> <== NOT EXECUTED return OBJECTS_INVALID_ADDRESS; if ( !name ) 1151fc: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 1151ff: 85 d2 test %edx,%edx <== NOT EXECUTED 115201: 74 4a je 11524d <_Objects_Name_to_id_string+0x61> <== NOT EXECUTED return OBJECTS_INVALID_NAME; if ( information->maximum != 0 ) { 115203: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 115206: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 115209: 66 85 c0 test %ax,%ax <== NOT EXECUTED 11520c: 74 3f je 11524d <_Objects_Name_to_id_string+0x61> <== NOT EXECUTED name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 11520e: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 115211: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 115214: 85 c0 test %eax,%eax <== NOT EXECUTED 115216: 74 35 je 11524d <_Objects_Name_to_id_string+0x61> <== NOT EXECUTED 115218: 8b 7a 1c mov 0x1c(%edx),%edi <== NOT EXECUTED 11521b: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED the_object = information->local_table[ index ]; 115220: 8b 34 9f mov (%edi,%ebx,4),%esi <== NOT EXECUTED if ( !the_object ) 115223: 85 f6 test %esi,%esi <== NOT EXECUTED 115225: 74 20 je 115247 <_Objects_Name_to_id_string+0x5b> <== NOT EXECUTED continue; if ( !the_object->name.name_p ) 115227: 8b 56 0c mov 0xc(%esi),%edx <== NOT EXECUTED 11522a: 85 d2 test %edx,%edx <== NOT EXECUTED 11522c: 74 19 je 115247 <_Objects_Name_to_id_string+0x5b> <== NOT EXECUTED continue; if (!strncmp( name, the_object->name.name_p, information->name_length)) { 11522e: 50 push %eax <== NOT EXECUTED 11522f: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 115232: 0f b7 41 3a movzwl 0x3a(%ecx),%eax <== NOT EXECUTED 115236: 50 push %eax <== NOT EXECUTED 115237: 52 push %edx <== NOT EXECUTED 115238: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11523b: e8 2c 27 00 00 call 11796c <== NOT EXECUTED 115240: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115243: 85 c0 test %eax,%eax <== NOT EXECUTED 115245: 74 15 je 11525c <_Objects_Name_to_id_string+0x70> <== NOT EXECUTED return OBJECTS_INVALID_NAME; if ( information->maximum != 0 ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 115247: 43 inc %ebx <== NOT EXECUTED 115248: 3b 5d f0 cmp -0x10(%ebp),%ebx <== NOT EXECUTED 11524b: 76 d3 jbe 115220 <_Objects_Name_to_id_string+0x34> <== NOT EXECUTED 11524d: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED } } } return OBJECTS_INVALID_NAME; } 115252: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 115255: 5b pop %ebx <== NOT EXECUTED 115256: 5e pop %esi <== NOT EXECUTED 115257: 5f pop %edi <== NOT EXECUTED 115258: c9 leave <== NOT EXECUTED 115259: c3 ret <== NOT EXECUTED 11525a: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !the_object->name.name_p ) continue; if (!strncmp( name, the_object->name.name_p, information->name_length)) { *id = the_object->id; 11525c: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 11525f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 115262: 89 02 mov %eax,(%edx) <== NOT EXECUTED 115264: 31 c0 xor %eax,%eax <== NOT EXECUTED } } } return OBJECTS_INVALID_NAME; } 115266: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 115269: 5b pop %ebx <== NOT EXECUTED 11526a: 5e pop %esi <== NOT EXECUTED 11526b: 5f pop %edi <== NOT EXECUTED 11526c: c9 leave <== NOT EXECUTED 11526d: c3 ret <== NOT EXECUTED 11526e: 66 90 xchg %ax,%ax <== NOT EXECUTED uint32_t index; uint32_t name_length; /* ASSERT: information->is_string == TRUE */ if ( !id ) 115270: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED } } } return OBJECTS_INVALID_NAME; } 115275: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 115278: 5b pop %ebx <== NOT EXECUTED 115279: 5e pop %esi <== NOT EXECUTED 11527a: 5f pop %edi <== NOT EXECUTED 11527b: c9 leave <== NOT EXECUTED 11527c: c3 ret <== NOT EXECUTED 0010bc60 <_Objects_Name_to_id_u32>: Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) { 10bc60: 55 push %ebp <== NOT EXECUTED 10bc61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc63: 57 push %edi <== NOT EXECUTED 10bc64: 56 push %esi <== NOT EXECUTED 10bc65: 53 push %ebx <== NOT EXECUTED 10bc66: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10bc69: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == FALSE */ if ( !id ) 10bc6c: 85 ff test %edi,%edi <== NOT EXECUTED 10bc6e: 74 5c je 10bccc <_Objects_Name_to_id_u32+0x6c> <== NOT EXECUTED return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 10bc70: 85 f6 test %esi,%esi <== NOT EXECUTED 10bc72: 74 38 je 10bcac <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10bc74: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bc77: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10bc7a: 66 85 c0 test %ax,%ax <== NOT EXECUTED 10bc7d: 74 2d je 10bcac <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED 10bc7f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10bc82: 85 d2 test %edx,%edx <== NOT EXECUTED 10bc84: 75 32 jne 10bcb8 <_Objects_Name_to_id_u32+0x58> <== NOT EXECUTED search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 10bc86: 0f b7 d8 movzwl %ax,%ebx <== NOT EXECUTED 10bc89: 85 db test %ebx,%ebx <== NOT EXECUTED 10bc8b: 74 1f je 10bcac <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10bc8d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bc90: 8b 48 1c mov 0x1c(%eax),%ecx <== NOT EXECUTED 10bc93: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { the_object = information->local_table[ index ]; 10bc98: 8b 04 91 mov (%ecx,%edx,4),%eax <== NOT EXECUTED if ( !the_object ) 10bc9b: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc9d: 74 05 je 10bca4 <_Objects_Name_to_id_u32+0x44> <== NOT EXECUTED continue; if ( name == the_object->name.name_u32 ) { 10bc9f: 39 70 0c cmp %esi,0xc(%eax) <== NOT EXECUTED 10bca2: 74 34 je 10bcd8 <_Objects_Name_to_id_u32+0x78> <== NOT EXECUTED search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 10bca4: 42 inc %edx <== NOT EXECUTED 10bca5: 39 da cmp %ebx,%edx <== NOT EXECUTED 10bca7: 76 ef jbe 10bc98 <_Objects_Name_to_id_u32+0x38> <== NOT EXECUTED 10bca9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10bcac: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif } 10bcb1: 5b pop %ebx <== NOT EXECUTED 10bcb2: 5e pop %esi <== NOT EXECUTED 10bcb3: 5f pop %edi <== NOT EXECUTED 10bcb4: c9 leave <== NOT EXECUTED 10bcb5: c3 ret <== NOT EXECUTED 10bcb6: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10bcb8: 81 7d 10 ff ff ff 7f cmpl $0x7fffffff,0x10(%ebp) <== NOT EXECUTED 10bcbf: 74 c5 je 10bc86 <_Objects_Name_to_id_u32+0x26> <== NOT EXECUTED 10bcc1: 83 7d 10 01 cmpl $0x1,0x10(%ebp) <== NOT EXECUTED 10bcc5: 75 e5 jne 10bcac <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED 10bcc7: eb bd jmp 10bc86 <_Objects_Name_to_id_u32+0x26> <== NOT EXECUTED 10bcc9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == FALSE */ if ( !id ) 10bccc: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif } 10bcd1: 5b pop %ebx <== NOT EXECUTED 10bcd2: 5e pop %esi <== NOT EXECUTED 10bcd3: 5f pop %edi <== NOT EXECUTED 10bcd4: c9 leave <== NOT EXECUTED 10bcd5: c3 ret <== NOT EXECUTED 10bcd6: 66 90 xchg %ax,%ax <== NOT EXECUTED the_object = information->local_table[ index ]; if ( !the_object ) continue; if ( name == the_object->name.name_u32 ) { *id = the_object->id; 10bcd8: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10bcdb: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10bcdd: 31 c0 xor %eax,%eax <== NOT EXECUTED name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif } 10bcdf: 5b pop %ebx <== NOT EXECUTED 10bce0: 5e pop %esi <== NOT EXECUTED 10bce1: 5f pop %edi <== NOT EXECUTED 10bce2: c9 leave <== NOT EXECUTED 10bce3: c3 ret <== NOT EXECUTED 0010bc2c <_Objects_Namespace_remove>: void _Objects_Namespace_remove( Objects_Information *information, Objects_Control *the_object ) { 10bc2c: 55 push %ebp <== NOT EXECUTED 10bc2d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc2f: 53 push %ebx <== NOT EXECUTED 10bc30: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bc33: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED /* * If this is a string format name, then free the memory. */ if ( information->is_string && the_object->name.name_p ) 10bc36: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bc39: 80 78 38 00 cmpb $0x0,0x38(%eax) <== NOT EXECUTED 10bc3d: 74 13 je 10bc52 <_Objects_Namespace_remove+0x26> <== NOT EXECUTED 10bc3f: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10bc42: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc44: 74 0c je 10bc52 <_Objects_Namespace_remove+0x26> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10bc46: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bc49: 50 push %eax <== NOT EXECUTED 10bc4a: e8 19 18 00 00 call 10d468 <_Workspace_Free> <== NOT EXECUTED 10bc4f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Clear out either format. */ the_object->name.name_p = NULL; the_object->name.name_u32 = 0; 10bc52: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED } 10bc59: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bc5c: c9 leave <== NOT EXECUTED 10bc5d: c3 ret <== NOT EXECUTED 0010c37c <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 10c37c: 55 push %ebp <== NOT EXECUTED 10c37d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c37f: 57 push %edi <== NOT EXECUTED 10c380: 56 push %esi <== NOT EXECUTED 10c381: 53 push %ebx <== NOT EXECUTED 10c382: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10c385: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10c388: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED size_t length; const char *s; s = name; length = strnlen( name, information->name_length ) + 1; 10c38b: 0f b7 43 3a movzwl 0x3a(%ebx),%eax <== NOT EXECUTED 10c38f: 50 push %eax <== NOT EXECUTED 10c390: 57 push %edi <== NOT EXECUTED 10c391: e8 4a 6a 00 00 call 112de0 <== NOT EXECUTED 10c396: 8d 70 01 lea 0x1(%eax),%esi <== NOT EXECUTED if ( information->is_string ) { 10c399: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c39c: 80 7b 38 00 cmpb $0x0,0x38(%ebx) <== NOT EXECUTED 10c3a0: 75 5a jne 10c3fc <_Objects_Set_name+0x80> <== NOT EXECUTED strncpy( d, name, length ); d[ length ] = '\0'; the_object->name.name_p = d; } else { the_object->name.name_u32 = _Objects_Build_name( 10c3a2: 85 f6 test %esi,%esi <== NOT EXECUTED 10c3a4: 74 3e je 10c3e4 <_Objects_Set_name+0x68> <== NOT EXECUTED 10c3a6: 0f be 17 movsbl (%edi),%edx <== NOT EXECUTED 10c3a9: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10c3ac: 83 fe 01 cmp $0x1,%esi <== NOT EXECUTED 10c3af: 0f 84 ae 00 00 00 je 10c463 <_Objects_Set_name+0xe7> <== NOT EXECUTED 10c3b5: 0f be 47 01 movsbl 0x1(%edi),%eax <== NOT EXECUTED 10c3b9: c1 e0 10 shl $0x10,%eax <== NOT EXECUTED 10c3bc: 09 d0 or %edx,%eax <== NOT EXECUTED 10c3be: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED 10c3c1: 0f 84 89 00 00 00 je 10c450 <_Objects_Set_name+0xd4> <== NOT EXECUTED 10c3c7: 0f be 57 02 movsbl 0x2(%edi),%edx <== NOT EXECUTED 10c3cb: c1 e2 08 shl $0x8,%edx <== NOT EXECUTED 10c3ce: 09 c2 or %eax,%edx <== NOT EXECUTED 10c3d0: 83 fe 03 cmp $0x3,%esi <== NOT EXECUTED 10c3d3: 0f 84 83 00 00 00 je 10c45c <_Objects_Set_name+0xe0> <== NOT EXECUTED 10c3d9: 0f be 47 03 movsbl 0x3(%edi),%eax <== NOT EXECUTED 10c3dd: 09 d0 or %edx,%eax <== NOT EXECUTED 10c3df: eb 08 jmp 10c3e9 <_Objects_Set_name+0x6d> <== NOT EXECUTED 10c3e1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10c3e4: b8 20 20 20 20 mov $0x20202020,%eax <== NOT EXECUTED 10c3e9: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c3ec: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 10c3ef: b0 01 mov $0x1,%al <== NOT EXECUTED ); } return TRUE; } 10c3f1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c3f4: 5b pop %ebx <== NOT EXECUTED 10c3f5: 5e pop %esi <== NOT EXECUTED 10c3f6: 5f pop %edi <== NOT EXECUTED 10c3f7: c9 leave <== NOT EXECUTED 10c3f8: c3 ret <== NOT EXECUTED 10c3f9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED length = strnlen( name, information->name_length ) + 1; if ( information->is_string ) { char *d; d = _Workspace_Allocate( length ); 10c3fc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c3ff: 56 push %esi <== NOT EXECUTED 10c400: e8 ff 17 00 00 call 10dc04 <_Workspace_Allocate> <== NOT EXECUTED 10c405: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !d ) 10c407: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c40a: 85 c0 test %eax,%eax <== NOT EXECUTED 10c40c: 74 4a je 10c458 <_Objects_Set_name+0xdc> <== NOT EXECUTED return FALSE; if ( the_object->name.name_p ) { 10c40e: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c411: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10c414: 85 c0 test %eax,%eax <== NOT EXECUTED 10c416: 74 16 je 10c42e <_Objects_Set_name+0xb2> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10c418: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c41b: 50 push %eax <== NOT EXECUTED 10c41c: e8 cb 17 00 00 call 10dbec <_Workspace_Free> <== NOT EXECUTED the_object->name.name_p = NULL; 10c421: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c424: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED 10c42b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } strncpy( d, name, length ); 10c42e: 50 push %eax <== NOT EXECUTED 10c42f: 56 push %esi <== NOT EXECUTED 10c430: 57 push %edi <== NOT EXECUTED 10c431: 53 push %ebx <== NOT EXECUTED 10c432: e8 21 69 00 00 call 112d58 <== NOT EXECUTED d[ length ] = '\0'; 10c437: c6 04 33 00 movb $0x0,(%ebx,%esi,1) <== NOT EXECUTED the_object->name.name_p = d; 10c43b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c43e: 89 5a 0c mov %ebx,0xc(%edx) <== NOT EXECUTED 10c441: b0 01 mov $0x1,%al <== NOT EXECUTED 10c443: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ); } return TRUE; } 10c446: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c449: 5b pop %ebx <== NOT EXECUTED 10c44a: 5e pop %esi <== NOT EXECUTED 10c44b: 5f pop %edi <== NOT EXECUTED 10c44c: c9 leave <== NOT EXECUTED 10c44d: c3 ret <== NOT EXECUTED 10c44e: 66 90 xchg %ax,%ax <== NOT EXECUTED strncpy( d, name, length ); d[ length ] = '\0'; the_object->name.name_p = d; } else { the_object->name.name_u32 = _Objects_Build_name( 10c450: 0d 20 20 00 00 or $0x2020,%eax <== NOT EXECUTED 10c455: eb 92 jmp 10c3e9 <_Objects_Set_name+0x6d> <== NOT EXECUTED 10c457: 90 nop <== NOT EXECUTED if ( information->is_string ) { char *d; d = _Workspace_Allocate( length ); if ( !d ) 10c458: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c45a: eb 95 jmp 10c3f1 <_Objects_Set_name+0x75> <== NOT EXECUTED strncpy( d, name, length ); d[ length ] = '\0'; the_object->name.name_p = d; } else { the_object->name.name_u32 = _Objects_Build_name( 10c45c: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c45e: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 10c461: eb 86 jmp 10c3e9 <_Objects_Set_name+0x6d> <== NOT EXECUTED 10c463: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c465: 0d 20 20 20 00 or $0x202020,%eax <== NOT EXECUTED 10c46a: e9 7a ff ff ff jmp 10c3e9 <_Objects_Set_name+0x6d> <== NOT EXECUTED 0010bcec <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 10bcec: 55 push %ebp <== NOT EXECUTED 10bced: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bcef: 57 push %edi <== NOT EXECUTED 10bcf0: 56 push %esi <== NOT EXECUTED 10bcf1: 53 push %ebx <== NOT EXECUTED 10bcf2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 10bcf5: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bcf8: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10bcfb: 0f b7 f0 movzwl %ax,%esi <== NOT EXECUTED /* * 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; 10bcfe: 8b 4a 14 mov 0x14(%edx),%ecx <== NOT EXECUTED 10bd01: 0f b7 42 10 movzwl 0x10(%edx),%eax <== NOT EXECUTED 10bd05: 29 f0 sub %esi,%eax <== NOT EXECUTED 10bd07: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bd09: f7 f1 div %ecx <== NOT EXECUTED for ( block = 0; block < block_count; block++ ) { 10bd0b: 85 c0 test %eax,%eax <== NOT EXECUTED 10bd0d: 74 24 je 10bd33 <_Objects_Shrink_information+0x47> <== NOT EXECUTED if ( information->inactive_per_block[ block ] == information->allocation_size ) { 10bd0f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bd12: 8b 5a 30 mov 0x30(%edx),%ebx <== NOT EXECUTED 10bd15: 3b 0b cmp (%ebx),%ecx <== NOT EXECUTED 10bd17: 74 22 je 10bd3b <_Objects_Shrink_information+0x4f> <== NOT EXECUTED information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; return; 10bd19: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bd1b: eb 11 jmp 10bd2e <_Objects_Shrink_information+0x42> <== NOT EXECUTED 10bd1d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } index_base += information->allocation_size; 10bd20: 01 ce add %ecx,%esi <== NOT EXECUTED 10bd22: 8d 3c 95 00 00 00 00 lea 0x0(,%edx,4),%edi <== NOT EXECUTED 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 ) { 10bd29: 3b 0c 93 cmp (%ebx,%edx,4),%ecx <== NOT EXECUTED 10bd2c: 74 12 je 10bd40 <_Objects_Shrink_information+0x54> <== NOT EXECUTED */ index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { 10bd2e: 42 inc %edx <== NOT EXECUTED 10bd2f: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10bd31: 77 ed ja 10bd20 <_Objects_Shrink_information+0x34> <== NOT EXECUTED return; } index_base += information->allocation_size; } } 10bd33: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bd36: 5b pop %ebx <== NOT EXECUTED 10bd37: 5e pop %esi <== NOT EXECUTED 10bd38: 5f pop %edi <== NOT EXECUTED 10bd39: c9 leave <== NOT EXECUTED 10bd3a: c3 ret <== NOT EXECUTED 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 ) { 10bd3b: 31 ff xor %edi,%edi <== NOT EXECUTED 10bd3d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * 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; 10bd40: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bd43: 8b 4b 20 mov 0x20(%ebx),%ecx <== NOT EXECUTED 10bd46: eb 26 jmp 10bd6e <_Objects_Shrink_information+0x82> <== NOT EXECUTED */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 10bd48: 89 f0 mov %esi,%eax <== NOT EXECUTED 10bd4a: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bd4d: 03 43 14 add 0x14(%ebx),%eax <== NOT EXECUTED 10bd50: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10bd52: 76 24 jbe 10bd78 <_Objects_Shrink_information+0x8c> <== NOT EXECUTED * @param[in] start_address is the starting address of the user block * to free * @return TRUE if successfully freed, FALSE otherwise */ bool _Protected_heap_Free( Heap_Control *the_heap, 10bd54: 8b 19 mov (%ecx),%ebx <== NOT EXECUTED if ( !_Chain_Is_last( &the_object->Node ) ) the_object = (Objects_Control *) the_object->Node.next; else the_object = NULL; _Chain_Extract( &extract_me->Node ); 10bd56: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bd59: 51 push %ecx <== NOT EXECUTED 10bd5a: e8 59 39 00 00 call 10f6b8 <_Chain_Extract> <== NOT EXECUTED 10bd5f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { the_object = (Objects_Control *) the_object->Node.next; } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 10bd62: 85 db test %ebx,%ebx <== NOT EXECUTED 10bd64: 74 1a je 10bd80 <_Objects_Shrink_information+0x94> <== NOT EXECUTED 10bd66: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10bd68: 85 c0 test %eax,%eax <== NOT EXECUTED 10bd6a: 74 14 je 10bd80 <_Objects_Shrink_information+0x94> <== NOT EXECUTED 10bd6c: 89 d9 mov %ebx,%ecx <== NOT EXECUTED * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes 10bd6e: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10bd71: 0f b7 d0 movzwl %ax,%edx <== NOT EXECUTED */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 10bd74: 39 f2 cmp %esi,%edx <== NOT EXECUTED 10bd76: 73 d0 jae 10bd48 <_Objects_Shrink_information+0x5c> <== NOT EXECUTED the_object = NULL; _Chain_Extract( &extract_me->Node ); } else { the_object = (Objects_Control *) the_object->Node.next; 10bd78: 8b 19 mov (%ecx),%ebx <== NOT EXECUTED } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 10bd7a: 85 db test %ebx,%ebx <== NOT EXECUTED 10bd7c: 75 e8 jne 10bd66 <_Objects_Shrink_information+0x7a> <== NOT EXECUTED 10bd7e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 10bd80: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bd83: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bd86: 8b 42 34 mov 0x34(%edx),%eax <== NOT EXECUTED 10bd89: ff 34 38 pushl (%eax,%edi,1) <== NOT EXECUTED 10bd8c: e8 d7 16 00 00 call 10d468 <_Workspace_Free> <== NOT EXECUTED information->object_blocks[ block ] = NULL; 10bd91: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bd94: 8b 43 34 mov 0x34(%ebx),%eax <== NOT EXECUTED 10bd97: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1) <== NOT EXECUTED information->inactive_per_block[ block ] = 0; 10bd9e: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10bda1: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1) <== NOT EXECUTED information->inactive -= information->allocation_size; 10bda8: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10bdab: 66 29 43 2c sub %ax,0x2c(%ebx) <== NOT EXECUTED 10bdaf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return; } index_base += information->allocation_size; } } 10bdb2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bdb5: 5b pop %ebx <== NOT EXECUTED 10bdb6: 5e pop %esi <== NOT EXECUTED 10bdb7: 5f pop %edi <== NOT EXECUTED 10bdb8: c9 leave <== NOT EXECUTED 10bdb9: c3 ret <== NOT EXECUTED 0010ab14 <_POSIX_API_Initialize>: void _POSIX_API_Initialize( rtems_configuration_table *configuration_table ) { 10ab14: 55 push %ebp <== NOT EXECUTED 10ab15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ab17: 53 push %ebx <== NOT EXECUTED 10ab18: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED /* XXX need to assert here based on size assumptions */ assert( sizeof(pthread_t) == sizeof(Objects_Id) ); api_configuration = configuration_table->POSIX_api_configuration; 10ab1b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ab1e: 8b 58 44 mov 0x44(%eax),%ebx <== NOT EXECUTED if ( !api_configuration ) 10ab21: 85 db test %ebx,%ebx <== NOT EXECUTED 10ab23: 74 7f je 10aba4 <_POSIX_API_Initialize+0x90> <== NOT EXECUTED api_configuration = &_POSIX_Default_configuration; _Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects; 10ab25: c7 05 98 f7 11 00 e0 movl $0x11fce0,0x11f798 <== NOT EXECUTED 10ab2c: fc 11 00 <== NOT EXECUTED _POSIX_signals_Manager_Initialization( 10ab2f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab32: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 10ab35: e8 4a 42 00 00 call 10ed84 <_POSIX_signals_Manager_Initialization> <== NOT EXECUTED api_configuration->maximum_queued_signals ); _POSIX_Threads_Manager_initialization( 10ab3a: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ab3d: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10ab40: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10ab43: ff 33 pushl (%ebx) <== NOT EXECUTED 10ab45: e8 ce 43 00 00 call 10ef18 <_POSIX_Threads_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_threads, api_configuration->number_of_initialization_threads, api_configuration->User_initialization_threads_table ); _POSIX_Condition_variables_Manager_initialization( 10ab4a: 58 pop %eax <== NOT EXECUTED 10ab4b: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10ab4e: e8 21 41 00 00 call 10ec74 <_POSIX_Condition_variables_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_condition_variables ); _POSIX_Key_Manager_initialization( api_configuration->maximum_keys ); 10ab53: 58 pop %eax <== NOT EXECUTED 10ab54: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10ab57: e8 40 41 00 00 call 10ec9c <_POSIX_Key_Manager_initialization> <== NOT EXECUTED _POSIX_Mutex_Manager_initialization( 10ab5c: 58 pop %eax <== NOT EXECUTED 10ab5d: ff 73 04 pushl 0x4(%ebx) <== NOT EXECUTED 10ab60: e8 a7 41 00 00 call 10ed0c <_POSIX_Mutex_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_mutexes ); _POSIX_Message_queue_Manager_initialization( 10ab65: 58 pop %eax <== NOT EXECUTED 10ab66: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10ab69: e8 56 41 00 00 call 10ecc4 <_POSIX_Message_queue_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_message_queues ); _POSIX_Semaphore_Manager_initialization( 10ab6e: 58 pop %eax <== NOT EXECUTED 10ab6f: ff 73 1c pushl 0x1c(%ebx) <== NOT EXECUTED 10ab72: e8 c5 46 00 00 call 10f23c <_POSIX_Semaphore_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_semaphores ); _POSIX_Timer_Manager_initialization( api_configuration->maximum_timers ); 10ab77: 59 pop %ecx <== NOT EXECUTED 10ab78: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10ab7b: e8 94 46 00 00 call 10f214 <_POSIX_Timer_Manager_initialization> <== NOT EXECUTED _POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers ); 10ab80: 5a pop %edx <== NOT EXECUTED 10ab81: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10ab84: e8 ab 41 00 00 call 10ed34 <_POSIX_Barrier_Manager_initialization> <== NOT EXECUTED _POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks ); 10ab89: 58 pop %eax <== NOT EXECUTED 10ab8a: ff 73 24 pushl 0x24(%ebx) <== NOT EXECUTED 10ab8d: e8 ca 41 00 00 call 10ed5c <_POSIX_RWLock_Manager_initialization> <== NOT EXECUTED _POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks); 10ab92: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab95: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10ab98: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10ab9b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ab9e: c9 leave <== NOT EXECUTED _POSIX_Barrier_Manager_initialization( api_configuration->maximum_barriers ); _POSIX_RWLock_Manager_initialization( api_configuration->maximum_rwlocks ); _POSIX_Spinlock_Manager_initialization(api_configuration->maximum_spinlocks); 10ab9f: e9 38 43 00 00 jmp 10eedc <_POSIX_Spinlock_Manager_initialization> <== NOT EXECUTED /* 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 ) 10aba4: bb a0 90 11 00 mov $0x1190a0,%ebx <== NOT EXECUTED 10aba9: e9 77 ff ff ff jmp 10ab25 <_POSIX_API_Initialize+0x11> <== NOT EXECUTED 0010c0e4 <_POSIX_Absolute_timeout_to_ticks>: */ POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks( const struct timespec *abstime, Watchdog_Interval *ticks_out ) { 10c0e4: 55 push %ebp <== NOT EXECUTED 10c0e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c0e7: 57 push %edi <== NOT EXECUTED 10c0e8: 56 push %esi <== NOT EXECUTED 10c0e9: 53 push %ebx <== NOT EXECUTED 10c0ea: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 10c0ed: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED /* * Make sure there is always a value returned. */ *ticks_out = 0; 10c0f0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c0f3: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED /* * Is the absolute time even valid? */ if ( !_Timespec_Is_valid(abstime) ) 10c0f9: 56 push %esi <== NOT EXECUTED 10c0fa: e8 bd 3e 00 00 call 10ffbc <_Timespec_Is_valid> <== NOT EXECUTED 10c0ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c102: 84 c0 test %al,%al <== NOT EXECUTED 10c104: 75 0a jne 10c110 <_POSIX_Absolute_timeout_to_ticks+0x2c> <== NOT EXECUTED 10c106: 31 c0 xor %eax,%eax <== NOT EXECUTED /* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; } 10c108: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c10b: 5b pop %ebx <== NOT EXECUTED 10c10c: 5e pop %esi <== NOT EXECUTED 10c10d: 5f pop %edi <== NOT EXECUTED 10c10e: c9 leave <== NOT EXECUTED 10c10f: c3 ret <== NOT EXECUTED return POSIX_ABSOLUTE_TIMEOUT_INVALID; /* * Is the absolute time in the past? */ _TOD_Get( ¤t_time ); 10c110: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c113: 8d 7d ec lea -0x14(%ebp),%edi <== NOT EXECUTED 10c116: 57 push %edi <== NOT EXECUTED 10c117: e8 1c 21 00 00 call 10e238 <_TOD_Get> <== NOT EXECUTED if ( _Timespec_Less_than( abstime, ¤t_time ) ) 10c11c: 5a pop %edx <== NOT EXECUTED 10c11d: 59 pop %ecx <== NOT EXECUTED 10c11e: 57 push %edi <== NOT EXECUTED 10c11f: 56 push %esi <== NOT EXECUTED 10c120: e8 bf 3e 00 00 call 10ffe4 <_Timespec_Less_than> <== NOT EXECUTED 10c125: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c128: 84 c0 test %al,%al <== NOT EXECUTED 10c12a: 74 10 je 10c13c <_POSIX_Absolute_timeout_to_ticks+0x58> <== NOT EXECUTED 10c12c: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED /* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; } 10c131: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c134: 5b pop %ebx <== NOT EXECUTED 10c135: 5e pop %esi <== NOT EXECUTED 10c136: 5f pop %edi <== NOT EXECUTED 10c137: c9 leave <== NOT EXECUTED 10c138: c3 ret <== NOT EXECUTED 10c139: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST; /* * How long until the requested absolute time? */ _Timespec_Subtract( ¤t_time, abstime, &difference ); 10c13c: 50 push %eax <== NOT EXECUTED 10c13d: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 10c140: 53 push %ebx <== NOT EXECUTED 10c141: 56 push %esi <== NOT EXECUTED 10c142: 57 push %edi <== NOT EXECUTED 10c143: e8 c0 3e 00 00 call 110008 <_Timespec_Subtract> <== NOT EXECUTED /* * Internally the SuperCore uses ticks, so convert to them. */ *ticks_out = _Timespec_To_ticks( &difference ); 10c148: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10c14b: e8 f4 3e 00 00 call 110044 <_Timespec_To_ticks> <== NOT EXECUTED 10c150: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c153: 89 02 mov %eax,(%edx) <== NOT EXECUTED /* * If the difference was 0, then the future is now. It is so bright * we better wear shades. */ if ( !*ticks_out ) 10c155: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c158: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10c15b: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10c15d: 83 c0 03 add $0x3,%eax <== NOT EXECUTED /* * This is the case we were expecting and it took this long to * get here. */ return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE; } 10c160: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c163: 5b pop %ebx <== NOT EXECUTED 10c164: 5e pop %esi <== NOT EXECUTED 10c165: 5f pop %edi <== NOT EXECUTED 10c166: c9 leave <== NOT EXECUTED 10c167: c3 ret <== NOT EXECUTED 0010ed34 <_POSIX_Barrier_Manager_initialization>: */ void _POSIX_Barrier_Manager_initialization( uint32_t maximum_barriers ) { 10ed34: 55 push %ebp <== NOT EXECUTED 10ed35: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ed37: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ed3a: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10ed3f: 6a 01 push $0x1 <== NOT EXECUTED 10ed41: 6a 5c push $0x5c <== NOT EXECUTED 10ed43: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ed46: 6a 0a push $0xa <== NOT EXECUTED 10ed48: 6a 03 push $0x3 <== NOT EXECUTED 10ed4a: 68 00 fc 11 00 push $0x11fc00 <== NOT EXECUTED 10ed4f: e8 18 ce ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10ed54: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ed57: c9 leave <== NOT EXECUTED 10ed58: c3 ret <== NOT EXECUTED 001101f4 <_POSIX_Barrier_Translate_core_barrier_return_code>: int _POSIX_Barrier_Translate_core_barrier_return_code( CORE_barrier_Status the_barrier_status ) { 1101f4: 55 push %ebp <== NOT EXECUTED 1101f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1101f7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1101fa: 8b 04 85 30 ad 11 00 mov 0x11ad30(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_barrier_status > CORE_BARRIER_STATUS_LAST ) return EINVAL; #endif return _POSIX_Barrier_Return_codes[the_barrier_status]; } 110201: c9 leave <== NOT EXECUTED 110202: c3 ret <== NOT EXECUTED 0010add0 <_POSIX_Condition_variables_Get>: POSIX_Condition_variables_Control *_POSIX_Condition_variables_Get ( pthread_cond_t *cond, Objects_Locations *location ) { 10add0: 55 push %ebp <== NOT EXECUTED 10add1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10add3: 53 push %ebx <== NOT EXECUTED 10add4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10add7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Objects_Id *id = (Objects_Id *)cond; int status; if ( !id ) { 10adda: 85 db test %ebx,%ebx <== NOT EXECUTED 10addc: 74 36 je 10ae14 <_POSIX_Condition_variables_Get+0x44> <== NOT EXECUTED *location = OBJECTS_ERROR; return (POSIX_Condition_variables_Control *) 0; } if ( *id == PTHREAD_COND_INITIALIZER ) { 10adde: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10ade0: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10ade3: 74 17 je 10adfc <_POSIX_Condition_variables_Get+0x2c> <== NOT EXECUTED /* * Now call Objects_Get() */ return (POSIX_Condition_variables_Control *) 10ade5: 52 push %edx <== NOT EXECUTED 10ade6: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10ade9: 50 push %eax <== NOT EXECUTED 10adea: 68 00 2c 12 00 push $0x122c00 <== NOT EXECUTED 10adef: e8 cc 2d 00 00 call 10dbc0 <_Objects_Get> <== NOT EXECUTED 10adf4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Objects_Get( &_POSIX_Condition_variables_Information, *id, location ); } 10adf7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10adfa: c9 leave <== NOT EXECUTED 10adfb: c3 ret <== NOT EXECUTED if ( *id == PTHREAD_COND_INITIALIZER ) { /* * Do an "auto-create" here. */ status = pthread_cond_init( (pthread_cond_t *)id, 0 ); 10adfc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10adff: 6a 00 push $0x0 <== NOT EXECUTED 10ae01: 53 push %ebx <== NOT EXECUTED 10ae02: e8 1d 00 00 00 call 10ae24 <== NOT EXECUTED if ( status ) { 10ae07: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae0a: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae0c: 75 06 jne 10ae14 <_POSIX_Condition_variables_Get+0x44> <== NOT EXECUTED 10ae0e: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10ae10: eb d3 jmp 10ade5 <_POSIX_Condition_variables_Get+0x15> <== NOT EXECUTED 10ae12: 66 90 xchg %ax,%ax <== NOT EXECUTED *location = OBJECTS_ERROR; 10ae14: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ae17: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10ae1d: 31 c0 xor %eax,%eax 10ae1f: eb d6 jmp 10adf7 <_POSIX_Condition_variables_Get+0x27> <== NOT EXECUTED 0010ec74 <_POSIX_Condition_variables_Manager_initialization>: */ void _POSIX_Condition_variables_Manager_initialization( uint32_t maximum_condition_variables ) { 10ec74: 55 push %ebp <== NOT EXECUTED 10ec75: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ec77: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ec7a: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10ec7f: 6a 01 push $0x1 <== NOT EXECUTED 10ec81: 6a 58 push $0x58 <== NOT EXECUTED 10ec83: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ec86: 6a 08 push $0x8 <== NOT EXECUTED 10ec88: 6a 03 push $0x3 <== NOT EXECUTED 10ec8a: 68 a0 fc 11 00 push $0x11fca0 <== NOT EXECUTED 10ec8f: e8 d8 ce ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10ec94: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ec97: c9 leave <== NOT EXECUTED 10ec98: c3 ret <== NOT EXECUTED 0010aeec <_POSIX_Condition_variables_Signal_support>: int _POSIX_Condition_variables_Signal_support( pthread_cond_t *cond, bool is_broadcast ) { 10aeec: 55 push %ebp <== NOT EXECUTED 10aeed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aeef: 56 push %esi <== NOT EXECUTED 10aef0: 53 push %ebx <== NOT EXECUTED 10aef1: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 10aef4: 8a 45 0c mov 0xc(%ebp),%al <== NOT EXECUTED 10aef7: 88 45 e7 mov %al,-0x19(%ebp) <== NOT EXECUTED register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; Thread_Control *the_thread; the_cond = _POSIX_Condition_variables_Get( cond, &location ); 10aefa: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10aefd: 50 push %eax <== NOT EXECUTED 10aefe: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10af01: e8 ca fe ff ff call 10add0 <_POSIX_Condition_variables_Get> <== NOT EXECUTED 10af06: 89 c6 mov %eax,%esi <== NOT EXECUTED switch ( location ) { 10af08: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af0b: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10af0e: 85 c0 test %eax,%eax <== NOT EXECUTED 10af10: 74 0e je 10af20 <_POSIX_Condition_variables_Signal_support+0x34> <== NOT EXECUTED 10af12: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10af17: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10af1a: 5b pop %ebx <== NOT EXECUTED 10af1b: 5e pop %esi <== NOT EXECUTED 10af1c: c9 leave <== NOT EXECUTED 10af1d: c3 ret <== NOT EXECUTED 10af1e: 66 90 xchg %ax,%ax <== NOT EXECUTED the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { case OBJECTS_LOCAL: do { the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue ); 10af20: 8d 5e 18 lea 0x18(%esi),%ebx <== NOT EXECUTED 10af23: eb 0d jmp 10af32 <_POSIX_Condition_variables_Signal_support+0x46> <== NOT EXECUTED 10af25: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !the_thread ) the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; } while ( is_broadcast && the_thread ); 10af28: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) <== NOT EXECUTED 10af2c: 74 22 je 10af50 <_POSIX_Condition_variables_Signal_support+0x64> <== NOT EXECUTED 10af2e: 85 c0 test %eax,%eax <== NOT EXECUTED 10af30: 74 1e je 10af50 <_POSIX_Condition_variables_Signal_support+0x64> <== NOT EXECUTED the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { case OBJECTS_LOCAL: do { the_thread = _Thread_queue_Dequeue( &the_cond->Wait_queue ); 10af32: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af35: 53 push %ebx <== NOT EXECUTED 10af36: e8 4d 38 00 00 call 10e788 <_Thread_queue_Dequeue> <== NOT EXECUTED if ( !the_thread ) 10af3b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af3e: 85 c0 test %eax,%eax <== NOT EXECUTED 10af40: 75 e6 jne 10af28 <_POSIX_Condition_variables_Signal_support+0x3c> <== NOT EXECUTED the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 10af42: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED } while ( is_broadcast && the_thread ); 10af49: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) <== NOT EXECUTED 10af4d: 75 df jne 10af2e <_POSIX_Condition_variables_Signal_support+0x42> <== NOT EXECUTED 10af4f: 90 nop <== NOT EXECUTED _Thread_Enable_dispatch(); 10af50: e8 af 34 00 00 call 10e404 <_Thread_Enable_dispatch> <== NOT EXECUTED 10af55: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10af57: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10af5a: 5b pop %ebx <== NOT EXECUTED 10af5b: 5e pop %esi <== NOT EXECUTED 10af5c: c9 leave <== NOT EXECUTED 10af5d: c3 ret <== NOT EXECUTED 0010afcc <_POSIX_Condition_variables_Wait_support>: pthread_cond_t *cond, pthread_mutex_t *mutex, Watchdog_Interval timeout, bool already_timedout ) { 10afcc: 55 push %ebp <== NOT EXECUTED 10afcd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10afcf: 56 push %esi <== NOT EXECUTED 10afd0: 53 push %ebx <== NOT EXECUTED 10afd1: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 10afd4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10afd7: 8a 45 14 mov 0x14(%ebp),%al <== NOT EXECUTED 10afda: 88 45 e7 mov %al,-0x19(%ebp) <== NOT EXECUTED register POSIX_Condition_variables_Control *the_cond; Objects_Locations location; int status; int mutex_status; if ( !_POSIX_Mutex_Get( mutex, &location ) ) { 10afdd: 8d 5d f4 lea -0xc(%ebp),%ebx <== NOT EXECUTED 10afe0: 53 push %ebx <== NOT EXECUTED 10afe1: 56 push %esi <== NOT EXECUTED 10afe2: e8 b1 01 00 00 call 10b198 <_POSIX_Mutex_Get> <== NOT EXECUTED 10afe7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10afea: 85 c0 test %eax,%eax <== NOT EXECUTED 10afec: 74 6e je 10b05c <_POSIX_Condition_variables_Wait_support+0x90> <== NOT EXECUTED 10afee: a1 18 27 12 00 mov 0x122718,%eax <== NOT EXECUTED 10aff3: 48 dec %eax <== NOT EXECUTED 10aff4: a3 18 27 12 00 mov %eax,0x122718 <== NOT EXECUTED return EINVAL; } _Thread_Unnest_dispatch(); the_cond = _POSIX_Condition_variables_Get( cond, &location ); 10aff9: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10affc: 53 push %ebx <== NOT EXECUTED 10affd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b000: e8 cb fd ff ff call 10add0 <_POSIX_Condition_variables_Get> <== NOT EXECUTED 10b005: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch ( location ) { 10b007: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b00a: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 10b00d: 85 d2 test %edx,%edx <== NOT EXECUTED 10b00f: 75 4b jne 10b05c <_POSIX_Condition_variables_Wait_support+0x90> <== NOT EXECUTED case OBJECTS_LOCAL: if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { 10b011: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10b014: 85 c0 test %eax,%eax <== NOT EXECUTED 10b016: 74 18 je 10b030 <_POSIX_Condition_variables_Wait_support+0x64> <== NOT EXECUTED 10b018: 3b 06 cmp (%esi),%eax <== NOT EXECUTED 10b01a: 74 14 je 10b030 <_POSIX_Condition_variables_Wait_support+0x64> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b01c: e8 e3 33 00 00 call 10e404 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b021: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10b026: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b028: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b02b: 5b pop %ebx <== NOT EXECUTED 10b02c: 5e pop %esi <== NOT EXECUTED 10b02d: c9 leave <== NOT EXECUTED 10b02e: c3 ret <== NOT EXECUTED 10b02f: 90 nop <== NOT EXECUTED if ( the_cond->Mutex && ( the_cond->Mutex != *mutex ) ) { _Thread_Enable_dispatch(); return EINVAL; } (void) pthread_mutex_unlock( mutex ); 10b030: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b033: 56 push %esi <== NOT EXECUTED 10b034: e8 77 03 00 00 call 10b3b0 <== NOT EXECUTED _Thread_Enable_dispatch(); return EINVAL; } */ if ( !already_timedout ) { 10b039: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b03c: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) <== NOT EXECUTED 10b040: 74 2a je 10b06c <_POSIX_Condition_variables_Wait_support+0xa0> <== NOT EXECUTED status = _Thread_Executing->Wait.return_code; if ( status && status != ETIMEDOUT ) return status; } else { _Thread_Enable_dispatch(); 10b042: e8 bd 33 00 00 call 10e404 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b047: bb 74 00 00 00 mov $0x74,%ebx <== NOT EXECUTED /* * When we get here the dispatch disable level is 0. */ mutex_status = pthread_mutex_lock( mutex ); 10b04c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b04f: 56 push %esi <== NOT EXECUTED 10b050: e8 d3 02 00 00 call 10b328 <== NOT EXECUTED if ( mutex_status ) 10b055: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b058: 85 c0 test %eax,%eax <== NOT EXECUTED 10b05a: 74 05 je 10b061 <_POSIX_Condition_variables_Wait_support+0x95> <== NOT EXECUTED 10b05c: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10b061: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b063: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b066: 5b pop %ebx <== NOT EXECUTED 10b067: 5e pop %esi <== NOT EXECUTED 10b068: c9 leave <== NOT EXECUTED 10b069: c3 ret <== NOT EXECUTED 10b06a: 66 90 xchg %ax,%ax <== NOT EXECUTED return EINVAL; } */ if ( !already_timedout ) { the_cond->Mutex = *mutex; 10b06c: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10b06e: 89 43 14 mov %eax,0x14(%ebx) <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10b071: c7 43 48 01 00 00 00 movl $0x1,0x48(%ebx) <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_cond->Wait_queue ); _Thread_Executing->Wait.return_code = 0; 10b078: 8b 15 dc 27 12 00 mov 0x1227dc,%edx <== NOT EXECUTED 10b07e: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED _Thread_Executing->Wait.queue = &the_cond->Wait_queue; 10b085: 8d 4b 18 lea 0x18(%ebx),%ecx <== NOT EXECUTED 10b088: 89 4a 44 mov %ecx,0x44(%edx) <== NOT EXECUTED _Thread_Executing->Wait.id = *cond; 10b08b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b08e: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10b090: 89 42 20 mov %eax,0x20(%edx) <== NOT EXECUTED _Thread_queue_Enqueue( &the_cond->Wait_queue, timeout ); 10b093: 50 push %eax <== NOT EXECUTED 10b094: 68 6c ec 10 00 push $0x10ec6c <== NOT EXECUTED 10b099: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10b09c: 51 push %ecx <== NOT EXECUTED 10b09d: e8 22 38 00 00 call 10e8c4 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b0a2: e8 5d 33 00 00 call 10e404 <_Thread_Enable_dispatch> <== NOT EXECUTED /* * Switch ourself out because we blocked as a result of the * _Thread_queue_Enqueue. */ status = _Thread_Executing->Wait.return_code; 10b0a7: a1 dc 27 12 00 mov 0x1227dc,%eax <== NOT EXECUTED 10b0ac: 8b 58 34 mov 0x34(%eax),%ebx <== NOT EXECUTED if ( status && status != ETIMEDOUT ) 10b0af: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b0b2: 85 db test %ebx,%ebx <== NOT EXECUTED 10b0b4: 74 96 je 10b04c <_POSIX_Condition_variables_Wait_support+0x80> <== NOT EXECUTED 10b0b6: 83 fb 74 cmp $0x74,%ebx <== NOT EXECUTED 10b0b9: 75 a6 jne 10b061 <_POSIX_Condition_variables_Wait_support+0x95> <== NOT EXECUTED 10b0bb: eb 8f jmp 10b04c <_POSIX_Condition_variables_Wait_support+0x80> <== NOT EXECUTED 0010ec9c <_POSIX_Key_Manager_initialization>: */ void _POSIX_Key_Manager_initialization( uint32_t maximum_keys ) { 10ec9c: 55 push %ebp <== NOT EXECUTED 10ec9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ec9f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10eca2: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10eca7: 6a 01 push $0x1 <== NOT EXECUTED 10eca9: 6a 2c push $0x2c <== NOT EXECUTED 10ecab: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ecae: 6a 02 push $0x2 <== NOT EXECUTED 10ecb0: 6a 03 push $0x3 <== NOT EXECUTED 10ecb2: 68 60 fc 11 00 push $0x11fc60 <== NOT EXECUTED 10ecb7: e8 b0 ce ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10ecbc: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ecbf: c9 leave <== NOT EXECUTED 10ecc0: c3 ret <== NOT EXECUTED 001104a8 <_POSIX_Keys_Run_destructors>: */ void _POSIX_Keys_Run_destructors( Thread_Control *thread ) { 1104a8: 55 push %ebp <== NOT EXECUTED 1104a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1104ab: 57 push %edi <== NOT EXECUTED 1104ac: 56 push %esi <== NOT EXECUTED 1104ad: 53 push %ebx <== NOT EXECUTED 1104ae: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED uint32_t iterations; bool are_all_null; POSIX_Keys_Control *the_key; void *value; thread_index = _Objects_Get_index( thread->Object.id ); 1104b1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1104b4: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 1104b7: 89 c2 mov %eax,%edx <== NOT EXECUTED 1104b9: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 1104bc: 83 e2 07 and $0x7,%edx <== NOT EXECUTED 1104bf: 8b 0d 70 fc 11 00 mov 0x11fc70,%ecx <== NOT EXECUTED 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 ]; 1104c5: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 1104ca: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 1104cd: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 1104d0: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) <== NOT EXECUTED 1104d7: 8d 7a 04 lea 0x4(%edx),%edi <== NOT EXECUTED for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 1104da: 66 85 c9 test %cx,%cx <== NOT EXECUTED 1104dd: 74 68 je 110547 <_POSIX_Keys_Run_destructors+0x9f> <== NOT EXECUTED 1104df: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 1104e4: c6 45 f3 01 movb $0x1,-0xd(%ebp) <== NOT EXECUTED the_key = (POSIX_Keys_Control *) 1104e8: a1 7c fc 11 00 mov 0x11fc7c,%eax <== NOT EXECUTED 1104ed: 8b 1c b0 mov (%eax,%esi,4),%ebx <== NOT EXECUTED _POSIX_Keys_Information.local_table[ index ]; if ( the_key && the_key->is_active && the_key->destructor ) { 1104f0: 85 db test %ebx,%ebx <== NOT EXECUTED 1104f2: 74 36 je 11052a <_POSIX_Keys_Run_destructors+0x82> <== NOT EXECUTED 1104f4: 80 7b 10 00 cmpb $0x0,0x10(%ebx) <== NOT EXECUTED 1104f8: 74 30 je 11052a <_POSIX_Keys_Run_destructors+0x82> <== NOT EXECUTED 1104fa: 8b 53 14 mov 0x14(%ebx),%edx <== NOT EXECUTED 1104fd: 85 d2 test %edx,%edx <== NOT EXECUTED 1104ff: 74 29 je 11052a <_POSIX_Keys_Run_destructors+0x82> <== NOT EXECUTED value = the_key->Values[ thread_api ][ thread_index ]; 110501: 8b 44 bb 08 mov 0x8(%ebx,%edi,4),%eax <== NOT EXECUTED 110505: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 110508: 8b 04 08 mov (%eax,%ecx,1),%eax <== NOT EXECUTED if ( value ) { 11050b: 85 c0 test %eax,%eax <== NOT EXECUTED 11050d: 74 1b je 11052a <_POSIX_Keys_Run_destructors+0x82> <== NOT EXECUTED (*the_key->destructor)( value ); 11050f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110512: 50 push %eax <== NOT EXECUTED 110513: ff d2 call *%edx <== NOT EXECUTED if ( the_key->Values[ thread_api ][ thread_index ] ) 110515: 8b 44 bb 08 mov 0x8(%ebx,%edi,4),%eax <== NOT EXECUTED 110519: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11051c: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 11051f: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 110522: 85 c0 test %eax,%eax <== NOT EXECUTED 110524: 74 04 je 11052a <_POSIX_Keys_Run_destructors+0x82> <== NOT EXECUTED 110526: c6 45 f3 00 movb $0x0,-0xd(%ebp) <== NOT EXECUTED for ( ; ; ) { are_all_null = TRUE; for ( index=1 ; index <= _POSIX_Keys_Information.maximum ; index++ ) { 11052a: 46 inc %esi <== NOT EXECUTED 11052b: 8b 0d 70 fc 11 00 mov 0x11fc70,%ecx <== NOT EXECUTED 110531: 0f b7 c1 movzwl %cx,%eax <== NOT EXECUTED 110534: 39 f0 cmp %esi,%eax <== NOT EXECUTED 110536: 73 b0 jae 1104e8 <_POSIX_Keys_Run_destructors+0x40> <== NOT EXECUTED are_all_null = FALSE; } } } if ( are_all_null == TRUE ) 110538: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 11053c: 75 09 jne 110547 <_POSIX_Keys_Run_destructors+0x9f> <== NOT EXECUTED return; iterations++; 11053e: ff 45 ec incl -0x14(%ebp) <== NOT EXECUTED * 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 ) 110541: 83 7d ec 04 cmpl $0x4,-0x14(%ebp) <== NOT EXECUTED 110545: 75 93 jne 1104da <_POSIX_Keys_Run_destructors+0x32> <== NOT EXECUTED return; } } 110547: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11054a: 5b pop %ebx <== NOT EXECUTED 11054b: 5e pop %esi <== NOT EXECUTED 11054c: 5f pop %edi <== NOT EXECUTED 11054d: c9 leave <== NOT EXECUTED 11054e: c3 ret <== NOT EXECUTED 001141b8 <_POSIX_Message_queue_Create_support>: const char *name_arg, int pshared, struct mq_attr *attr_ptr, POSIX_Message_queue_Control **message_queue ) { 1141b8: 55 push %ebp <== NOT EXECUTED 1141b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1141bb: 57 push %edi <== NOT EXECUTED 1141bc: 56 push %esi <== NOT EXECUTED 1141bd: 53 push %ebx <== NOT EXECUTED 1141be: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 1141c1: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED CORE_message_queue_Attributes *the_mq_attr; struct mq_attr attr; char *name; size_t n; n = strnlen( name_arg, NAME_MAX ); 1141c4: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 1141c9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1141cc: e8 cf 38 00 00 call 117aa0 <== NOT EXECUTED 1141d1: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( n > NAME_MAX ) 1141d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1141d6: 3d ff 00 00 00 cmp $0xff,%eax <== NOT EXECUTED 1141db: 0f 87 d7 00 00 00 ja 1142b8 <_POSIX_Message_queue_Create_support+0x100> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1141e1: a1 58 7c 12 00 mov 0x127c58,%eax <== NOT EXECUTED 1141e6: 40 inc %eax <== NOT EXECUTED 1141e7: a3 58 7c 12 00 mov %eax,0x127c58 <== NOT EXECUTED * 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 ) { 1141ec: 85 f6 test %esi,%esi <== NOT EXECUTED 1141ee: 0f 84 d4 00 00 00 je 1142c8 <_POSIX_Message_queue_Create_support+0x110> <== NOT EXECUTED attr.mq_maxmsg = 10; attr.mq_msgsize = 16; } else { if ( attr_ptr->mq_maxmsg <= 0 ){ 1141f4: 8b 56 04 mov 0x4(%esi),%edx <== NOT EXECUTED 1141f7: 85 d2 test %edx,%edx <== NOT EXECUTED 1141f9: 0f 8e 0d 01 00 00 jle 11430c <_POSIX_Message_queue_Create_support+0x154> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ 1141ff: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 114202: 85 c0 test %eax,%eax <== NOT EXECUTED 114204: 0f 8e 02 01 00 00 jle 11430c <_POSIX_Message_queue_Create_support+0x154> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } attr = *attr_ptr; 11420a: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 11420d: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 114212: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 114214: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 114217: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 11421a: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11421d: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus extern "C" { 114220: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114223: 68 20 80 12 00 push $0x128020 <== NOT EXECUTED 114228: e8 cf c6 ff ff call 1108fc <_Objects_Allocate> <== NOT EXECUTED 11422d: 89 c7 mov %eax,%edi <== NOT EXECUTED } the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { 11422f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114232: 85 c0 test %eax,%eax <== NOT EXECUTED 114234: 0f 84 e9 00 00 00 je 114323 <_POSIX_Message_queue_Create_support+0x16b> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq->process_shared = pshared; 11423a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11423d: 89 47 10 mov %eax,0x10(%edi) <== NOT EXECUTED the_mq->named = TRUE; 114240: c6 47 14 01 movb $0x1,0x14(%edi) <== NOT EXECUTED the_mq->open_count = 1; 114244: c7 47 18 01 00 00 00 movl $0x1,0x18(%edi) <== NOT EXECUTED the_mq->linked = TRUE; 11424b: c6 47 15 01 movb $0x1,0x15(%edi) <== NOT EXECUTED /* * Make a copy of the user's string for name just in case it was * dynamically constructed. */ name = _Workspace_Allocate(n); 11424f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114252: 53 push %ebx <== NOT EXECUTED 114253: e8 50 e6 ff ff call 1128a8 <_Workspace_Allocate> <== NOT EXECUTED 114258: 89 c6 mov %eax,%esi <== NOT EXECUTED if (!name) { 11425a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11425d: 85 c0 test %eax,%eax <== NOT EXECUTED 11425f: 0f 84 d8 00 00 00 je 11433d <_POSIX_Message_queue_Create_support+0x185> <== NOT EXECUTED _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOMEM ); } strcpy( name, name_arg ); 114265: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114268: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11426b: 50 push %eax <== NOT EXECUTED 11426c: e8 13 34 00 00 call 117684 <== NOT EXECUTED * 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; 114271: c7 47 5c 00 00 00 00 movl $0x0,0x5c(%edi) <== NOT EXECUTED if ( ! _CORE_message_queue_Initialize( 114278: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED 11427b: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 11427e: 8d 47 5c lea 0x5c(%edi),%eax <== NOT EXECUTED 114281: 50 push %eax <== NOT EXECUTED 114282: 8d 47 1c lea 0x1c(%edi),%eax <== NOT EXECUTED 114285: 50 push %eax <== NOT EXECUTED 114286: e8 f9 0a 00 00 call 114d84 <_CORE_message_queue_Initialize> <== NOT EXECUTED 11428b: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 11428e: 84 c0 test %al,%al <== NOT EXECUTED 114290: 74 4a je 1142dc <_POSIX_Message_queue_Create_support+0x124> <== NOT EXECUTED 114292: 0f b7 57 08 movzwl 0x8(%edi),%edx <== NOT EXECUTED 114296: a1 3c 80 12 00 mov 0x12803c,%eax <== NOT EXECUTED 11429b: 89 3c 90 mov %edi,(%eax,%edx,4) <== NOT EXECUTED 11429e: 89 77 0c mov %esi,0xc(%edi) <== NOT EXECUTED &_POSIX_Message_queue_Information, &the_mq->Object, name ); *message_queue = the_mq; 1142a1: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1142a4: 89 38 mov %edi,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 1142a6: e8 dd d3 ff ff call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED 1142ab: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 1142ad: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1142b0: 5b pop %ebx <== NOT EXECUTED 1142b1: 5e pop %esi <== NOT EXECUTED 1142b2: 5f pop %edi <== NOT EXECUTED 1142b3: c9 leave <== NOT EXECUTED 1142b4: c3 ret <== NOT EXECUTED 1142b5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED struct mq_attr attr; char *name; size_t n; n = strnlen( name_arg, NAME_MAX ); if ( n > NAME_MAX ) 1142b8: b8 5b 00 00 00 mov $0x5b,%eax <== NOT EXECUTED *message_queue = the_mq; _Thread_Enable_dispatch(); return 0; } 1142bd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1142c0: 5b pop %ebx <== NOT EXECUTED 1142c1: 5e pop %esi <== NOT EXECUTED 1142c2: 5f pop %edi <== NOT EXECUTED 1142c3: c9 leave <== NOT EXECUTED 1142c4: c3 ret <== NOT EXECUTED 1142c5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * 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 ) { 1142c8: c7 45 dc 10 00 00 00 movl $0x10,-0x24(%ebp) <== NOT EXECUTED 1142cf: c7 45 e0 0a 00 00 00 movl $0xa,-0x20(%ebp) <== NOT EXECUTED 1142d6: e9 45 ff ff ff jmp 114220 <_POSIX_Message_queue_Create_support+0x68> <== NOT EXECUTED 1142db: 90 nop <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 1142dc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1142df: 57 push %edi <== NOT EXECUTED 1142e0: 68 20 80 12 00 push $0x128020 <== NOT EXECUTED 1142e5: e8 d2 c9 ff ff call 110cbc <_Objects_Free> <== NOT EXECUTED attr.mq_maxmsg, attr.mq_msgsize ) ) { _POSIX_Message_queue_Free( the_mq ); _Workspace_Free(name); 1142ea: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 1142ed: e8 9e e5 ff ff call 112890 <_Workspace_Free> <== NOT EXECUTED _Thread_Enable_dispatch(); 1142f2: e8 91 d3 ff ff call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 1142f7: e8 50 22 00 00 call 11654c <__errno> <== NOT EXECUTED 1142fc: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 114302: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 114307: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11430a: eb a1 jmp 1142ad <_POSIX_Message_queue_Create_support+0xf5> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( attr_ptr->mq_msgsize <= 0 ){ _Thread_Enable_dispatch(); 11430c: e8 77 d3 ff ff call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 114311: e8 36 22 00 00 call 11654c <__errno> <== NOT EXECUTED 114316: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11431c: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 114321: eb 8a jmp 1142ad <_POSIX_Message_queue_Create_support+0xf5> <== NOT EXECUTED attr = *attr_ptr; } the_mq = _POSIX_Message_queue_Allocate(); if ( !the_mq ) { _Thread_Enable_dispatch(); 114323: e8 60 d3 ff ff call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENFILE ); 114328: e8 1f 22 00 00 call 11654c <__errno> <== NOT EXECUTED 11432d: c7 00 17 00 00 00 movl $0x17,(%eax) <== NOT EXECUTED 114333: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 114338: e9 70 ff ff ff jmp 1142ad <_POSIX_Message_queue_Create_support+0xf5> <== NOT EXECUTED 11433d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114340: 57 push %edi <== NOT EXECUTED 114341: 68 20 80 12 00 push $0x128020 <== NOT EXECUTED 114346: e8 71 c9 ff ff call 110cbc <_Objects_Free> <== NOT EXECUTED */ name = _Workspace_Allocate(n); if (!name) { _POSIX_Message_queue_Free( the_mq ); _Thread_Enable_dispatch(); 11434b: e8 38 d3 ff ff call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); 114350: e8 f7 21 00 00 call 11654c <__errno> <== NOT EXECUTED 114355: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 11435b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 114360: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114363: e9 45 ff ff ff jmp 1142ad <_POSIX_Message_queue_Create_support+0xf5> <== NOT EXECUTED 0010d8c0 <_POSIX_Message_queue_Delete>: */ void _POSIX_Message_queue_Delete( POSIX_Message_queue_Control *the_mq ) { 10d8c0: 55 push %ebp <== NOT EXECUTED 10d8c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d8c3: 53 push %ebx <== NOT EXECUTED 10d8c4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d8c7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( !the_mq->linked && !the_mq->open_count ) { 10d8ca: 80 7b 15 00 cmpb $0x0,0x15(%ebx) <== NOT EXECUTED 10d8ce: 75 48 jne 10d918 <_POSIX_Message_queue_Delete+0x58> <== NOT EXECUTED 10d8d0: 8b 4b 18 mov 0x18(%ebx),%ecx <== NOT EXECUTED 10d8d3: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d8d5: 75 41 jne 10d918 <_POSIX_Message_queue_Delete+0x58> <== NOT EXECUTED /* the name memory may have been freed by unlink. */ Objects_Control *the_object = &the_mq->Object; if ( the_object->name.name_p ) 10d8d7: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10d8da: 85 c0 test %eax,%eax <== NOT EXECUTED 10d8dc: 74 0c je 10d8ea <_POSIX_Message_queue_Delete+0x2a> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10d8de: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d8e1: 50 push %eax <== NOT EXECUTED 10d8e2: e8 a9 4f 00 00 call 112890 <_Workspace_Free> <== NOT EXECUTED 10d8e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Objects_Close( &_POSIX_Message_queue_Information, the_object ); 10d8ea: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d8ed: 53 push %ebx <== NOT EXECUTED 10d8ee: 68 20 80 12 00 push $0x128020 <== NOT EXECUTED 10d8f3: e8 84 30 00 00 call 11097c <_Objects_Close> <== NOT EXECUTED _CORE_message_queue_Close( 10d8f8: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10d8fb: 6a 05 push $0x5 <== NOT EXECUTED 10d8fd: 6a 00 push $0x0 <== NOT EXECUTED 10d8ff: 8d 43 1c lea 0x1c(%ebx),%eax <== NOT EXECUTED 10d902: 50 push %eax <== NOT EXECUTED 10d903: e8 04 26 00 00 call 10ff0c <_CORE_message_queue_Close> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 10d908: 58 pop %eax <== NOT EXECUTED 10d909: 5a pop %edx <== NOT EXECUTED 10d90a: 53 push %ebx <== NOT EXECUTED 10d90b: 68 20 80 12 00 push $0x128020 <== NOT EXECUTED 10d910: e8 a7 33 00 00 call 110cbc <_Objects_Free> <== NOT EXECUTED 10d915: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ); _POSIX_Message_queue_Free( the_mq ); } } 10d918: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d91b: c9 leave <== NOT EXECUTED 10d91c: c3 ret <== NOT EXECUTED 0010ecc4 <_POSIX_Message_queue_Manager_initialization>: */ void _POSIX_Message_queue_Manager_initialization( uint32_t maximum_message_queues ) { 10ecc4: 55 push %ebp <== NOT EXECUTED 10ecc5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ecc7: 53 push %ebx <== NOT EXECUTED 10ecc8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10eccb: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Objects_Initialize_information( 10ecce: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10ecd3: 6a 01 push $0x1 <== NOT EXECUTED 10ecd5: 68 a4 00 00 00 push $0xa4 <== NOT EXECUTED 10ecda: 53 push %ebx <== NOT EXECUTED 10ecdb: 6a 05 push $0x5 <== NOT EXECUTED 10ecdd: 6a 03 push $0x3 <== NOT EXECUTED 10ecdf: 68 80 fb 11 00 push $0x11fb80 <== NOT EXECUTED 10ece4: e8 83 ce ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); _Objects_Initialize_information( 10ece9: 83 c4 1c add $0x1c,%esp <== NOT EXECUTED 10ecec: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10ecf1: 6a 01 push $0x1 <== NOT EXECUTED 10ecf3: 6a 18 push $0x18 <== NOT EXECUTED 10ecf5: 53 push %ebx <== NOT EXECUTED 10ecf6: 6a 04 push $0x4 <== NOT EXECUTED 10ecf8: 6a 03 push $0x3 <== NOT EXECUTED 10ecfa: 68 20 fd 11 00 push $0x11fd20 <== NOT EXECUTED 10ecff: e8 68 ce ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10ed04: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ed07: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ed0a: c9 leave <== NOT EXECUTED 10ed0b: c3 ret <== NOT EXECUTED 00114368 <_POSIX_Message_queue_Name_to_id>: int _POSIX_Message_queue_Name_to_id( const char *name, Objects_Id *id ) { 114368: 55 push %ebp <== NOT EXECUTED 114369: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11436b: 57 push %edi <== NOT EXECUTED 11436c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 11436f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; if ( !name ) 114372: 85 d2 test %edx,%edx <== NOT EXECUTED 114374: 74 05 je 11437b <_POSIX_Message_queue_Name_to_id+0x13> <== NOT EXECUTED return EINVAL; if ( !name[0] ) 114376: 80 3a 00 cmpb $0x0,(%edx) <== NOT EXECUTED 114379: 75 0d jne 114388 <_POSIX_Message_queue_Name_to_id+0x20> <== NOT EXECUTED return ENAMETOOLONG; status = _Objects_Name_to_id_string( &_POSIX_Message_queue_Information, name, id ); if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) 11437b: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return 0; return ENOENT; } 114380: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 114383: c9 leave <== NOT EXECUTED 114384: c3 ret <== NOT EXECUTED 114385: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return EINVAL; if ( !name[0] ) return EINVAL; if( strlen(name) > PATH_MAX ) 114388: 31 c0 xor %eax,%eax <== NOT EXECUTED 11438a: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 11438f: 89 d7 mov %edx,%edi <== NOT EXECUTED 114391: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 114393: f7 d1 not %ecx <== NOT EXECUTED 114395: 49 dec %ecx <== NOT EXECUTED 114396: 81 f9 ff 00 00 00 cmp $0xff,%ecx <== NOT EXECUTED 11439c: 76 0a jbe 1143a8 <_POSIX_Message_queue_Name_to_id+0x40> <== NOT EXECUTED 11439e: b8 5b 00 00 00 mov $0x5b,%eax <== NOT EXECUTED if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) return 0; return ENOENT; } 1143a3: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 1143a6: c9 leave <== NOT EXECUTED 1143a7: c3 ret <== NOT EXECUTED return EINVAL; if( strlen(name) > PATH_MAX ) return ENAMETOOLONG; status = _Objects_Name_to_id_string( 1143a8: 50 push %eax <== NOT EXECUTED 1143a9: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1143ac: 52 push %edx <== NOT EXECUTED 1143ad: 68 20 80 12 00 push $0x128020 <== NOT EXECUTED 1143b2: e8 35 0e 00 00 call 1151ec <_Objects_Name_to_id_string> <== NOT EXECUTED &_POSIX_Message_queue_Information, name, id ); if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) 1143b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1143ba: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 1143bd: 19 c0 sbb %eax,%eax <== NOT EXECUTED 1143bf: f7 d0 not %eax <== NOT EXECUTED 1143c1: 83 e0 02 and $0x2,%eax <== NOT EXECUTED return 0; return ENOENT; } 1143c4: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 1143c7: c9 leave <== NOT EXECUTED 1143c8: c3 ret <== NOT EXECUTED 0010da40 <_POSIX_Message_queue_Notify_handler>: */ void _POSIX_Message_queue_Notify_handler( void *user_data ) { 10da40: 55 push %ebp <== NOT EXECUTED 10da41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10da43: 56 push %esi <== NOT EXECUTED 10da44: 53 push %ebx <== NOT EXECUTED 10da45: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED POSIX_Message_queue_Control *the_mq; the_mq = user_data; kill( getpid(), the_mq->notification.sigev_signo ); 10da48: 8b b3 94 00 00 00 mov 0x94(%ebx),%esi <== NOT EXECUTED 10da4e: e8 89 60 00 00 call 113adc <== NOT EXECUTED 10da53: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10da56: 56 push %esi <== NOT EXECUTED 10da57: 50 push %eax <== NOT EXECUTED 10da58: e8 43 67 00 00 call 1141a0 <== NOT EXECUTED 10da5d: c7 43 7c 00 00 00 00 movl $0x0,0x7c(%ebx) <== NOT EXECUTED 10da64: c7 83 80 00 00 00 00 movl $0x0,0x80(%ebx) <== NOT EXECUTED 10da6b: 00 00 00 <== NOT EXECUTED 10da6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); } 10da71: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10da74: 5b pop %ebx <== NOT EXECUTED 10da75: 5e pop %esi <== NOT EXECUTED 10da76: c9 leave <== NOT EXECUTED 10da77: c3 ret <== NOT EXECUTED 0010dc4c <_POSIX_Message_queue_Receive_support>: size_t msg_len, unsigned int *msg_prio, bool wait, Watchdog_Interval timeout ) { 10dc4c: 55 push %ebp <== NOT EXECUTED 10dc4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc4f: 57 push %edi <== NOT EXECUTED 10dc50: 56 push %esi <== NOT EXECUTED 10dc51: 53 push %ebx <== NOT EXECUTED 10dc52: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 10dc55: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10dc58: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 10dc5b: 8a 5d 18 mov 0x18(%ebp),%bl <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 10dc5e: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10dc61: 50 push %eax <== NOT EXECUTED 10dc62: 57 push %edi <== NOT EXECUTED 10dc63: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10dc68: e8 83 31 00 00 call 110df0 <_Objects_Get> <== NOT EXECUTED 10dc6d: 89 c2 mov %eax,%edx <== NOT EXECUTED Objects_Locations location; size_t length_out; bool do_wait; the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 10dc6f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dc72: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10dc75: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10dc77: 74 1b je 10dc94 <_POSIX_Message_queue_Receive_support+0x48> <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10dc79: e8 ce 88 00 00 call 11654c <__errno> <== NOT EXECUTED 10dc7e: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10dc84: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 10dc89: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dc8c: 5b pop %ebx <== NOT EXECUTED 10dc8d: 5e pop %esi <== NOT EXECUTED 10dc8e: 5f pop %edi <== NOT EXECUTED 10dc8f: c9 leave <== NOT EXECUTED 10dc90: c3 ret <== NOT EXECUTED 10dc91: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { 10dc94: 8b 48 14 mov 0x14(%eax),%ecx <== NOT EXECUTED 10dc97: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10dc99: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 10dc9c: 48 dec %eax <== NOT EXECUTED 10dc9d: 0f 84 af 00 00 00 je 10dd52 <_POSIX_Message_queue_Receive_support+0x106> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10dca3: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED if ( msg_len < the_mq->Message_queue.maximum_message_size ) { 10dca6: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10dca9: 39 42 68 cmp %eax,0x68(%edx) <== NOT EXECUTED 10dcac: 77 62 ja 10dd10 <_POSIX_Message_queue_Receive_support+0xc4> <== NOT EXECUTED length_out = -1; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10dcae: 84 db test %bl,%bl <== NOT EXECUTED 10dcb0: 75 4a jne 10dcfc <_POSIX_Message_queue_Receive_support+0xb0> <== NOT EXECUTED 10dcb2: 31 c0 xor %eax,%eax <== NOT EXECUTED /* * Now if something goes wrong, we return a "length" of -1 * to indicate an error. */ length_out = -1; 10dcb4: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp) <== NOT EXECUTED do_wait = wait; /* * Now perform the actual message receive */ _CORE_message_queue_Seize( 10dcbb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dcbe: ff 75 1c pushl 0x1c(%ebp) <== NOT EXECUTED 10dcc1: 50 push %eax <== NOT EXECUTED 10dcc2: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10dcc5: 50 push %eax <== NOT EXECUTED 10dcc6: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dcc9: 57 push %edi <== NOT EXECUTED 10dcca: 8d 42 1c lea 0x1c(%edx),%eax <== NOT EXECUTED 10dccd: 50 push %eax <== NOT EXECUTED 10dcce: e8 bd 22 00 00 call 10ff90 <_CORE_message_queue_Seize> <== NOT EXECUTED &length_out, do_wait, timeout ); _Thread_Enable_dispatch(); 10dcd3: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10dcd6: e8 ad 39 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED *msg_prio = 10dcdb: 8b 15 1c 7d 12 00 mov 0x127d1c,%edx <== NOT EXECUTED 10dce1: 8b 42 24 mov 0x24(%edx),%eax <== NOT EXECUTED 10dce4: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10dce6: 85 c0 test %eax,%eax <== NOT EXECUTED 10dce8: 78 22 js 10dd0c <_POSIX_Message_queue_Receive_support+0xc0> <== NOT EXECUTED _POSIX_Message_queue_Priority_from_core(_Thread_Executing->Wait.count); if ( !_Thread_Executing->Wait.return_code ) 10dcea: 8b 42 34 mov 0x34(%edx),%eax <== NOT EXECUTED 10dced: 85 c0 test %eax,%eax <== NOT EXECUTED 10dcef: 75 3b jne 10dd2c <_POSIX_Message_queue_Receive_support+0xe0> <== NOT EXECUTED return length_out; 10dcf1: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); } 10dcf4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dcf7: 5b pop %ebx <== NOT EXECUTED 10dcf8: 5e pop %esi <== NOT EXECUTED 10dcf9: 5f pop %edi <== NOT EXECUTED 10dcfa: c9 leave <== NOT EXECUTED 10dcfb: c3 ret <== NOT EXECUTED length_out = -1; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10dcfc: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10dcfe: c1 e8 0e shr $0xe,%eax <== NOT EXECUTED 10dd01: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 10dd04: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10dd07: eb ab jmp 10dcb4 <_POSIX_Message_queue_Receive_support+0x68> <== NOT EXECUTED 10dd09: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED do_wait, timeout ); _Thread_Enable_dispatch(); *msg_prio = 10dd0c: f7 1e negl (%esi) <== NOT EXECUTED 10dd0e: eb da jmp 10dcea <_POSIX_Message_queue_Receive_support+0x9e> <== NOT EXECUTED } the_mq = the_mq_fd->Queue; if ( msg_len < the_mq->Message_queue.maximum_message_size ) { _Thread_Enable_dispatch(); 10dd10: e8 73 39 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EMSGSIZE ); 10dd15: e8 32 88 00 00 call 11654c <__errno> <== NOT EXECUTED 10dd1a: c7 00 7a 00 00 00 movl $0x7a,(%eax) <== NOT EXECUTED 10dd20: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10dd25: e9 5f ff ff ff jmp 10dc89 <_POSIX_Message_queue_Receive_support+0x3d> <== NOT EXECUTED 10dd2a: 66 90 xchg %ax,%ax <== NOT EXECUTED _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( 10dd2c: e8 1b 88 00 00 call 11654c <__errno> <== NOT EXECUTED 10dd31: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10dd33: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10dd36: a1 1c 7d 12 00 mov 0x127d1c,%eax <== NOT EXECUTED 10dd3b: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10dd3e: e8 31 02 00 00 call 10df74 <_POSIX_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 10dd43: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10dd45: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10dd4a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dd4d: e9 37 ff ff ff jmp 10dc89 <_POSIX_Message_queue_Receive_support+0x3d> <== NOT EXECUTED the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) { _Thread_Enable_dispatch(); 10dd52: e8 31 39 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 10dd57: e8 f0 87 00 00 call 11654c <__errno> <== NOT EXECUTED 10dd5c: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10dd62: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10dd67: e9 1d ff ff ff jmp 10dc89 <_POSIX_Message_queue_Receive_support+0x3d> <== NOT EXECUTED 0010dd8c <_POSIX_Message_queue_Send_support>: size_t msg_len, uint32_t msg_prio, bool wait, Watchdog_Interval timeout ) { 10dd8c: 55 push %ebp <== NOT EXECUTED 10dd8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dd8f: 56 push %esi <== NOT EXECUTED 10dd90: 53 push %ebx <== NOT EXECUTED 10dd91: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 10dd94: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10dd97: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 10dd9a: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 10dd9d: 88 45 e7 mov %al,-0x19(%ebp) <== NOT EXECUTED /* * Validate the priority. * XXX - Do not validate msg_prio is not less than 0. */ if ( msg_prio > MQ_PRIO_MAX ) 10dda0: 83 fb 20 cmp $0x20,%ebx <== NOT EXECUTED 10dda3: 0f 87 93 00 00 00 ja 10de3c <_POSIX_Message_queue_Send_support+0xb0> <== NOT EXECUTED 10dda9: 51 push %ecx <== NOT EXECUTED 10ddaa: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10ddad: 50 push %eax <== NOT EXECUTED 10ddae: 56 push %esi <== NOT EXECUTED 10ddaf: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10ddb4: e8 37 30 00 00 call 110df0 <_Objects_Get> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 10ddb9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ddbc: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 10ddbf: 85 d2 test %edx,%edx <== NOT EXECUTED 10ddc1: 75 65 jne 10de28 <_POSIX_Message_queue_Send_support+0x9c> <== NOT EXECUTED case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) { 10ddc3: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED 10ddc6: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10ddc9: 0f 84 81 00 00 00 je 10de50 <_POSIX_Message_queue_Send_support+0xc4> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EBADF ); } the_mq = the_mq_fd->Queue; 10ddcf: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10ddd2: 80 7d e7 00 cmpb $0x0,-0x19(%ebp) <== NOT EXECUTED 10ddd6: 75 38 jne 10de10 <_POSIX_Message_queue_Send_support+0x84> <== NOT EXECUTED 10ddd8: 31 d2 xor %edx,%edx <== NOT EXECUTED do_wait = wait; /* * Now perform the actual message receive */ msg_status = _CORE_message_queue_Submit( 10ddda: ff 75 1c pushl 0x1c(%ebp) <== NOT EXECUTED 10dddd: 52 push %edx <== NOT EXECUTED 10ddde: f7 db neg %ebx <== NOT EXECUTED 10dde0: 53 push %ebx <== NOT EXECUTED 10dde1: 6a 00 push $0x0 <== NOT EXECUTED 10dde3: 56 push %esi <== NOT EXECUTED 10dde4: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dde7: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10ddea: 83 c0 1c add $0x1c,%eax <== NOT EXECUTED 10dded: 50 push %eax <== NOT EXECUTED 10ddee: e8 c9 22 00 00 call 1100bc <_CORE_message_queue_Submit> <== NOT EXECUTED 10ddf3: 89 c6 mov %eax,%esi <== NOT EXECUTED _POSIX_Message_queue_Priority_to_core( msg_prio ), do_wait, timeout /* no timeout */ ); _Thread_Enable_dispatch(); 10ddf5: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10ddf8: e8 8b 38 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED * 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 ) 10ddfd: 83 fe 07 cmp $0x7,%esi <== NOT EXECUTED 10de00: 74 1a je 10de1c <_POSIX_Message_queue_Send_support+0x90> <== NOT EXECUTED msg_status = _Thread_Executing->Wait.return_code; if ( !msg_status ) 10de02: 85 f6 test %esi,%esi <== NOT EXECUTED 10de04: 75 62 jne 10de68 <_POSIX_Message_queue_Send_support+0xdc> <== NOT EXECUTED 10de06: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); } 10de08: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10de0b: 5b pop %ebx <== NOT EXECUTED 10de0c: 5e pop %esi <== NOT EXECUTED 10de0d: c9 leave <== NOT EXECUTED 10de0e: c3 ret <== NOT EXECUTED 10de0f: 90 nop <== NOT EXECUTED the_mq = the_mq_fd->Queue; /* * A timed receive with a bad time will do a poll regardless. */ if ( wait ) 10de10: c1 ea 0e shr $0xe,%edx <== NOT EXECUTED 10de13: 83 f2 01 xor $0x1,%edx <== NOT EXECUTED 10de16: 83 e2 01 and $0x1,%edx <== NOT EXECUTED 10de19: eb bf jmp 10ddda <_POSIX_Message_queue_Send_support+0x4e> <== NOT EXECUTED 10de1b: 90 nop <== NOT EXECUTED * 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 ) msg_status = _Thread_Executing->Wait.return_code; 10de1c: a1 1c 7d 12 00 mov 0x127d1c,%eax <== NOT EXECUTED 10de21: 8b 70 34 mov 0x34(%eax),%esi <== NOT EXECUTED 10de24: eb dc jmp 10de02 <_POSIX_Message_queue_Send_support+0x76> <== NOT EXECUTED 10de26: 66 90 xchg %ax,%ax <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10de28: e8 1f 87 00 00 call 11654c <__errno> <== NOT EXECUTED 10de2d: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10de33: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10de38: eb ce jmp 10de08 <_POSIX_Message_queue_Send_support+0x7c> <== NOT EXECUTED 10de3a: 66 90 xchg %ax,%ax <== NOT EXECUTED * 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 ); 10de3c: e8 0b 87 00 00 call 11654c <__errno> <== NOT EXECUTED 10de41: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10de47: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10de4c: eb ba jmp 10de08 <_POSIX_Message_queue_Send_support+0x7c> <== NOT EXECUTED 10de4e: 66 90 xchg %ax,%ax <== NOT EXECUTED the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) { _Thread_Enable_dispatch(); 10de50: e8 33 38 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 10de55: e8 f2 86 00 00 call 11654c <__errno> <== NOT EXECUTED 10de5a: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10de60: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10de65: eb a1 jmp 10de08 <_POSIX_Message_queue_Send_support+0x7c> <== NOT EXECUTED 10de67: 90 nop <== NOT EXECUTED msg_status = _Thread_Executing->Wait.return_code; if ( !msg_status ) return msg_status; rtems_set_errno_and_return_minus_one( 10de68: e8 df 86 00 00 call 11654c <__errno> <== NOT EXECUTED 10de6d: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10de6f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10de72: 56 push %esi <== NOT EXECUTED 10de73: e8 fc 00 00 00 call 10df74 <_POSIX_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 10de78: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10de7a: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10de7f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10de82: eb 84 jmp 10de08 <_POSIX_Message_queue_Send_support+0x7c> <== NOT EXECUTED 0010df74 <_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 ) { 10df74: 55 push %ebp <== NOT EXECUTED 10df75: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df77: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10df7a: 8b 04 85 40 12 12 00 mov 0x121240(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_message_queue_status > CORE_MESSAGE_QUEUE_STATUS_LAST ) return EINVAL; #endif return _POSIX_Message_queue_Return_codes[the_message_queue_status]; } 10df81: c9 leave <== NOT EXECUTED 10df82: c3 ret <== NOT EXECUTED 0010bd50 <_POSIX_Mutex_Get>: POSIX_Mutex_Control *_POSIX_Mutex_Get ( pthread_mutex_t *mutex, Objects_Locations *location ) { 10bd50: 55 push %ebp <== NOT EXECUTED 10bd51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd53: 53 push %ebx <== NOT EXECUTED 10bd54: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bd57: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 10bd5a: 85 db test %ebx,%ebx <== NOT EXECUTED 10bd5c: 74 36 je 10bd94 <_POSIX_Mutex_Get+0x44> <== NOT EXECUTED 10bd5e: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10bd60: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10bd63: 74 17 je 10bd7c <_POSIX_Mutex_Get+0x2c> <== NOT EXECUTED return (POSIX_Mutex_Control *) 10bd65: 52 push %edx <== NOT EXECUTED 10bd66: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10bd69: 50 push %eax <== NOT EXECUTED 10bd6a: 68 a0 55 12 00 push $0x1255a0 <== NOT EXECUTED 10bd6f: e8 9c 2d 00 00 call 10eb10 <_Objects_Get> <== NOT EXECUTED 10bd74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Objects_Get( &_POSIX_Mutex_Information, *id, location ); } 10bd77: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bd7a: c9 leave <== NOT EXECUTED 10bd7b: c3 ret <== NOT EXECUTED Objects_Locations *location ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 10bd7c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bd7f: 6a 00 push $0x0 <== NOT EXECUTED 10bd81: 53 push %ebx <== NOT EXECUTED 10bd82: e8 69 00 00 00 call 10bdf0 <== NOT EXECUTED 10bd87: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bd8a: 85 c0 test %eax,%eax <== NOT EXECUTED 10bd8c: 75 06 jne 10bd94 <_POSIX_Mutex_Get+0x44> <== NOT EXECUTED 10bd8e: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10bd90: eb d3 jmp 10bd65 <_POSIX_Mutex_Get+0x15> <== NOT EXECUTED 10bd92: 66 90 xchg %ax,%ax <== NOT EXECUTED 10bd94: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10bd97: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10bd9d: 31 c0 xor %eax,%eax 10bd9f: eb d6 jmp 10bd77 <_POSIX_Mutex_Get+0x27> <== NOT EXECUTED 0010bcf8 <_POSIX_Mutex_Get_interrupt_disable>: POSIX_Mutex_Control *_POSIX_Mutex_Get_interrupt_disable ( pthread_mutex_t *mutex, Objects_Locations *location, ISR_Level *level ) { 10bcf8: 55 push %ebp <== NOT EXECUTED 10bcf9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bcfb: 53 push %ebx <== NOT EXECUTED 10bcfc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bcff: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 10bd02: 85 db test %ebx,%ebx <== NOT EXECUTED 10bd04: 74 3a je 10bd40 <_POSIX_Mutex_Get_interrupt_disable+0x48> <== NOT EXECUTED 10bd06: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10bd08: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10bd0b: 74 1b je 10bd28 <_POSIX_Mutex_Get_interrupt_disable+0x30> <== NOT EXECUTED return (POSIX_Mutex_Control *) 10bd0d: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10bd10: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10bd13: 50 push %eax <== NOT EXECUTED 10bd14: 68 a0 55 12 00 push $0x1255a0 <== NOT EXECUTED 10bd19: e8 a6 2d 00 00 call 10eac4 <_Objects_Get_isr_disable> <== NOT EXECUTED 10bd1e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Objects_Get_isr_disable( &_POSIX_Mutex_Information, *id, location, level ); } 10bd21: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bd24: c9 leave <== NOT EXECUTED 10bd25: c3 ret <== NOT EXECUTED 10bd26: 66 90 xchg %ax,%ax <== NOT EXECUTED ISR_Level *level ) { Objects_Id *id = (Objects_Id *)mutex; ___POSIX_Mutex_Get_support( id, location ); 10bd28: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bd2b: 6a 00 push $0x0 <== NOT EXECUTED 10bd2d: 53 push %ebx <== NOT EXECUTED 10bd2e: e8 bd 00 00 00 call 10bdf0 <== NOT EXECUTED 10bd33: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bd36: 85 c0 test %eax,%eax <== NOT EXECUTED 10bd38: 75 06 jne 10bd40 <_POSIX_Mutex_Get_interrupt_disable+0x48> <== NOT EXECUTED 10bd3a: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10bd3c: eb cf jmp 10bd0d <_POSIX_Mutex_Get_interrupt_disable+0x15> <== NOT EXECUTED 10bd3e: 66 90 xchg %ax,%ax <== NOT EXECUTED 10bd40: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10bd43: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10bd49: 31 c0 xor %eax,%eax 10bd4b: eb d4 jmp 10bd21 <_POSIX_Mutex_Get_interrupt_disable+0x29> <== NOT EXECUTED 0010bf40 <_POSIX_Mutex_Lock_support>: int _POSIX_Mutex_Lock_support( pthread_mutex_t *mutex, bool blocking, Watchdog_Interval timeout ) { 10bf40: 55 push %ebp <== NOT EXECUTED 10bf41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf43: 53 push %ebx <== NOT EXECUTED 10bf44: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10bf47: 8a 5d 0c mov 0xc(%ebp),%bl <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; ISR_Level level; the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &location, &level ); 10bf4a: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10bf4d: 50 push %eax <== NOT EXECUTED 10bf4e: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10bf51: 50 push %eax <== NOT EXECUTED 10bf52: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bf55: e8 9e fd ff ff call 10bcf8 <_POSIX_Mutex_Get_interrupt_disable> <== NOT EXECUTED 10bf5a: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 10bf5c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bf5f: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10bf62: 85 c0 test %eax,%eax <== NOT EXECUTED 10bf64: 75 32 jne 10bf98 <_POSIX_Mutex_Lock_support+0x58> <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_mutex_Seize( 10bf66: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bf69: ff 75 f4 pushl -0xc(%ebp) <== NOT EXECUTED 10bf6c: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10bf6f: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10bf72: 50 push %eax <== NOT EXECUTED 10bf73: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 10bf76: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 10bf79: 50 push %eax <== NOT EXECUTED 10bf7a: e8 79 20 00 00 call 10dff8 <_CORE_mutex_Seize> <== NOT EXECUTED the_mutex->Object.id, blocking, timeout, level ); return _POSIX_Mutex_Translate_core_mutex_return_code( 10bf7f: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10bf82: a1 5c 52 12 00 mov 0x12525c,%eax <== NOT EXECUTED 10bf87: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10bf8a: e8 e1 00 00 00 call 10c070 <_POSIX_Mutex_Translate_core_mutex_return_code> <== NOT EXECUTED 10bf8f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10bf92: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bf95: c9 leave <== NOT EXECUTED 10bf96: c3 ret <== NOT EXECUTED 10bf97: 90 nop <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; ISR_Level level; the_mutex = _POSIX_Mutex_Get_interrupt_disable( mutex, &location, &level ); switch ( location ) { 10bf98: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10bf9d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bfa0: c9 leave <== NOT EXECUTED 10bfa1: c3 ret <== NOT EXECUTED 0010ed0c <_POSIX_Mutex_Manager_initialization>: */ void _POSIX_Mutex_Manager_initialization( uint32_t maximum_mutexes ) { 10ed0c: 55 push %ebp <== NOT EXECUTED 10ed0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ed0f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ed12: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10ed17: 6a 01 push $0x1 <== NOT EXECUTED 10ed19: 6a 78 push $0x78 <== NOT EXECUTED 10ed1b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ed1e: 6a 06 push $0x6 <== NOT EXECUTED 10ed20: 6a 03 push $0x3 <== NOT EXECUTED 10ed22: 68 c0 fb 11 00 push $0x11fbc0 <== NOT EXECUTED 10ed27: e8 40 ce ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10ed2c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ed2f: c9 leave <== NOT EXECUTED 10ed30: c3 ret <== NOT EXECUTED 0010c070 <_POSIX_Mutex_Translate_core_mutex_return_code>: int _POSIX_Mutex_Translate_core_mutex_return_code( CORE_mutex_Status the_mutex_status ) { 10c070: 55 push %ebp <== NOT EXECUTED 10c071: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c073: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c076: 8b 04 85 8c e7 11 00 mov 0x11e78c(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_mutex_status > CORE_MUTEX_STATUS_LAST ) return EINVAL; #endif return _POSIX_Mutex_Return_codes[the_mutex_status]; } 10c07d: c9 leave <== NOT EXECUTED 10c07e: c3 ret <== NOT EXECUTED 0010ed5c <_POSIX_RWLock_Manager_initialization>: */ void _POSIX_RWLock_Manager_initialization( uint32_t maximum_rwlocks ) { 10ed5c: 55 push %ebp <== NOT EXECUTED 10ed5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ed5f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ed62: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10ed67: 6a 01 push $0x1 <== NOT EXECUTED 10ed69: 6a 5c push $0x5c <== NOT EXECUTED 10ed6b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ed6e: 6a 0b push $0xb <== NOT EXECUTED 10ed70: 6a 03 push $0x3 <== NOT EXECUTED 10ed72: 68 40 fa 11 00 push $0x11fa40 <== NOT EXECUTED 10ed77: e8 f0 cd ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10ed7c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ed7f: c9 leave <== NOT EXECUTED 10ed80: c3 ret <== NOT EXECUTED 0010ae00 <_POSIX_RWLock_Translate_core_RWLock_return_code>: int _POSIX_RWLock_Translate_core_RWLock_return_code( CORE_RWLock_Status the_rwlock_status ) { 10ae00: 55 push %ebp <== NOT EXECUTED 10ae01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae03: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ae06: 8b 04 85 48 b8 11 00 mov 0x11b848(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_rwlock_status > CORE_RWLOCK_STATUS_LAST ) return EINVAL; #endif return _POSIX_RWLock_Return_codes[the_rwlock_status]; } 10ae0d: c9 leave <== NOT EXECUTED 10ae0e: c3 ret <== NOT EXECUTED 001126a4 <_POSIX_Semaphore_Create_support>: const char *name, int pshared, unsigned int value, POSIX_Semaphore_Control **the_sem ) { 1126a4: 55 push %ebp <== NOT EXECUTED 1126a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1126a7: 57 push %edi <== NOT EXECUTED 1126a8: 56 push %esi <== NOT EXECUTED 1126a9: 53 push %ebx <== NOT EXECUTED 1126aa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1126ad: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1126b0: a1 d8 58 12 00 mov 0x1258d8,%eax <== NOT EXECUTED 1126b5: 40 inc %eax <== NOT EXECUTED 1126b6: a3 d8 58 12 00 mov %eax,0x1258d8 <== NOT EXECUTED char *name_p = (char *)name; _Thread_Disable_dispatch(); /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) { 1126bb: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 1126be: 85 d2 test %edx,%edx <== NOT EXECUTED 1126c0: 0f 85 ae 00 00 00 jne 112774 <_POSIX_Semaphore_Create_support+0xd0> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOSYS ); } if ( name ) { 1126c6: 85 f6 test %esi,%esi <== NOT EXECUTED 1126c8: 74 1a je 1126e4 <_POSIX_Semaphore_Create_support+0x40> <== NOT EXECUTED if( strlen(name) > PATH_MAX ) { 1126ca: 31 c0 xor %eax,%eax <== NOT EXECUTED 1126cc: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 1126d1: 89 f7 mov %esi,%edi <== NOT EXECUTED 1126d3: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 1126d5: f7 d1 not %ecx <== NOT EXECUTED 1126d7: 49 dec %ecx <== NOT EXECUTED 1126d8: 81 f9 ff 00 00 00 cmp $0xff,%ecx <== NOT EXECUTED 1126de: 0f 87 a8 00 00 00 ja 11278c <_POSIX_Semaphore_Create_support+0xe8> <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 1126e4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1126e7: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 1126ec: e8 3b bf ff ff call 10e62c <_Objects_Allocate> <== NOT EXECUTED 1126f1: 89 c3 mov %eax,%ebx <== NOT EXECUTED } } the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { 1126f3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1126f6: 85 c0 test %eax,%eax <== NOT EXECUTED 1126f8: 0f 84 a5 00 00 00 je 1127a3 <_POSIX_Semaphore_Create_support+0xff> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENOSPC ); } the_semaphore->process_shared = pshared; 1126fe: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) <== NOT EXECUTED if ( name ) { 112705: 85 f6 test %esi,%esi <== NOT EXECUTED 112707: 74 57 je 112760 <_POSIX_Semaphore_Create_support+0xbc> <== NOT EXECUTED the_semaphore->named = TRUE; 112709: c6 40 14 01 movb $0x1,0x14(%eax) <== NOT EXECUTED the_semaphore->open_count = 1; 11270d: c7 40 18 01 00 00 00 movl $0x1,0x18(%eax) <== NOT EXECUTED the_semaphore->linked = TRUE; 112714: c6 40 15 01 movb $0x1,0x15(%eax) <== NOT EXECUTED * 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; 112718: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED /* * This effectively disables limit checking. */ the_sem_attr->maximum_count = 0xFFFFFFFF; 11271f: c7 43 5c ff ff ff ff movl $0xffffffff,0x5c(%ebx) <== NOT EXECUTED _CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value ); 112726: 50 push %eax <== NOT EXECUTED 112727: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11272a: 8d 43 5c lea 0x5c(%ebx),%eax <== NOT EXECUTED 11272d: 50 push %eax <== NOT EXECUTED 11272e: 8d 43 1c lea 0x1c(%ebx),%eax <== NOT EXECUTED 112731: 50 push %eax <== NOT EXECUTED 112732: e8 fd ba ff ff call 10e234 <_CORE_semaphore_Initialize> <== NOT EXECUTED 112737: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 11273b: a1 3c 5c 12 00 mov 0x125c3c,%eax <== NOT EXECUTED 112740: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 112743: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_POSIX_Semaphore_Information, &the_semaphore->Object, name_p ); *the_sem = the_semaphore; 112746: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 112749: 89 18 mov %ebx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 11274b: e8 14 cc ff ff call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED 112750: 31 c0 xor %eax,%eax <== NOT EXECUTED 112752: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 112755: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112758: 5b pop %ebx <== NOT EXECUTED 112759: 5e pop %esi <== NOT EXECUTED 11275a: 5f pop %edi <== NOT EXECUTED 11275b: c9 leave <== NOT EXECUTED 11275c: c3 ret <== NOT EXECUTED 11275d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( name ) { the_semaphore->named = TRUE; the_semaphore->open_count = 1; the_semaphore->linked = TRUE; } else { the_semaphore->named = FALSE; 112760: c6 40 14 00 movb $0x0,0x14(%eax) <== NOT EXECUTED the_semaphore->open_count = 0; 112764: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED the_semaphore->linked = FALSE; 11276b: c6 40 15 00 movb $0x0,0x15(%eax) <== NOT EXECUTED 11276f: eb a7 jmp 112718 <_POSIX_Semaphore_Create_support+0x74> <== NOT EXECUTED 112771: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* Sharing semaphores among processes is not currently supported */ if (pshared != 0) { _Thread_Enable_dispatch(); 112774: e8 eb cb ff ff call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 112779: e8 0a 1d 00 00 call 114488 <__errno> <== NOT EXECUTED 11277e: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED 112784: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 112789: eb ca jmp 112755 <_POSIX_Semaphore_Create_support+0xb1> <== NOT EXECUTED 11278b: 90 nop <== NOT EXECUTED } if ( name ) { if( strlen(name) > PATH_MAX ) { _Thread_Enable_dispatch(); 11278c: e8 d3 cb ff ff call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENAMETOOLONG ); 112791: e8 f2 1c 00 00 call 114488 <__errno> <== NOT EXECUTED 112796: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED 11279c: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1127a1: eb b2 jmp 112755 <_POSIX_Semaphore_Create_support+0xb1> <== NOT EXECUTED } the_semaphore = _POSIX_Semaphore_Allocate(); if ( !the_semaphore ) { _Thread_Enable_dispatch(); 1127a3: e8 bc cb ff ff call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 1127a8: e8 db 1c 00 00 call 114488 <__errno> <== NOT EXECUTED 1127ad: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 1127b3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1127b8: eb 9b jmp 112755 <_POSIX_Semaphore_Create_support+0xb1> <== NOT EXECUTED 001127bc <_POSIX_Semaphore_Delete>: */ void _POSIX_Semaphore_Delete( POSIX_Semaphore_Control *the_semaphore ) { 1127bc: 55 push %ebp <== NOT EXECUTED 1127bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1127bf: 53 push %ebx <== NOT EXECUTED 1127c0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1127c3: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( !the_semaphore->linked && !the_semaphore->open_count ) { 1127c6: 80 7b 15 00 cmpb $0x0,0x15(%ebx) <== NOT EXECUTED 1127ca: 75 07 jne 1127d3 <_POSIX_Semaphore_Delete+0x17> <== NOT EXECUTED 1127cc: 8b 4b 18 mov 0x18(%ebx),%ecx <== NOT EXECUTED 1127cf: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1127d1: 74 05 je 1127d8 <_POSIX_Semaphore_Delete+0x1c> <== NOT EXECUTED -1 ); _POSIX_Semaphore_Free( the_semaphore ); } } 1127d3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1127d6: c9 leave <== NOT EXECUTED 1127d7: c3 ret <== NOT EXECUTED void _POSIX_Semaphore_Delete( POSIX_Semaphore_Control *the_semaphore ) { if ( !the_semaphore->linked && !the_semaphore->open_count ) { _Objects_Close( &_POSIX_Semaphore_Information, &the_semaphore->Object ); 1127d8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1127db: 53 push %ebx <== NOT EXECUTED 1127dc: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 1127e1: e8 c6 be ff ff call 10e6ac <_Objects_Close> <== NOT EXECUTED _CORE_semaphore_Flush( 1127e6: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1127e9: 6a ff push $0xffffffff <== NOT EXECUTED 1127eb: 6a 00 push $0x0 <== NOT EXECUTED 1127ed: 8d 43 1c lea 0x1c(%ebx),%eax <== NOT EXECUTED 1127f0: 50 push %eax <== NOT EXECUTED 1127f1: e8 32 ba ff ff call 10e228 <_CORE_semaphore_Flush> <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 1127f6: 58 pop %eax <== NOT EXECUTED 1127f7: 5a pop %edx <== NOT EXECUTED 1127f8: 53 push %ebx <== NOT EXECUTED 1127f9: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 1127fe: e8 e9 c1 ff ff call 10e9ec <_Objects_Free> <== NOT EXECUTED 112803: 83 c4 10 add $0x10,%esp <== NOT EXECUTED -1 ); _POSIX_Semaphore_Free( the_semaphore ); } } 112806: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112809: c9 leave <== NOT EXECUTED 11280a: c3 ret <== NOT EXECUTED 0010f23c <_POSIX_Semaphore_Manager_initialization>: */ void _POSIX_Semaphore_Manager_initialization( uint32_t maximum_semaphores ) { 10f23c: 55 push %ebp <== NOT EXECUTED 10f23d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f23f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f242: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10f247: 6a 01 push $0x1 <== NOT EXECUTED 10f249: 6a 68 push $0x68 <== NOT EXECUTED 10f24b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f24e: 6a 07 push $0x7 <== NOT EXECUTED 10f250: 6a 03 push $0x3 <== NOT EXECUTED 10f252: 68 00 fb 11 00 push $0x11fb00 <== NOT EXECUTED 10f257: e8 10 c9 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f25c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10f25f: c9 leave <== NOT EXECUTED 10f260: c3 ret <== NOT EXECUTED 0011280c <_POSIX_Semaphore_Name_to_id>: int _POSIX_Semaphore_Name_to_id( const char *name, sem_t *id ) { 11280c: 55 push %ebp <== NOT EXECUTED 11280d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11280f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 112812: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; if ( !name ) 112815: 85 c0 test %eax,%eax <== NOT EXECUTED 112817: 74 05 je 11281e <_POSIX_Semaphore_Name_to_id+0x12> <== NOT EXECUTED return EINVAL; if ( !name[0] ) 112819: 80 38 00 cmpb $0x0,(%eax) <== NOT EXECUTED 11281c: 75 0a jne 112828 <_POSIX_Semaphore_Name_to_id+0x1c> <== NOT EXECUTED return EINVAL; status = _Objects_Name_to_id_string( &_POSIX_Semaphore_Information, name, (Objects_Id*)id ); if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) 11281e: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return 0; return ENOENT; } 112823: c9 leave <== NOT EXECUTED 112824: c3 ret <== NOT EXECUTED 112825: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return EINVAL; if ( !name[0] ) return EINVAL; status = _Objects_Name_to_id_string( 112828: 52 push %edx <== NOT EXECUTED 112829: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11282c: 50 push %eax <== NOT EXECUTED 11282d: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 112832: e8 59 0a 00 00 call 113290 <_Objects_Name_to_id_string> <== NOT EXECUTED &_POSIX_Semaphore_Information, name, (Objects_Id*)id ); if ( status == OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL ) 112837: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11283a: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 11283d: 19 c0 sbb %eax,%eax <== NOT EXECUTED 11283f: f7 d0 not %eax <== NOT EXECUTED 112841: 83 e0 02 and $0x2,%eax <== NOT EXECUTED return 0; return ENOENT; } 112844: c9 leave <== NOT EXECUTED 112845: c3 ret <== NOT EXECUTED 00113f84 <_POSIX_Semaphore_Translate_core_semaphore_return_code>: int _POSIX_Semaphore_Translate_core_semaphore_return_code( CORE_semaphore_Status the_semaphore_status ) { 113f84: 55 push %ebp <== NOT EXECUTED 113f85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113f87: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 113f8a: 8b 04 85 54 ef 11 00 mov 0x11ef54(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_semaphore_status > CORE_SEMAPHORE_STATUS_LAST ) return EINVAL; #endif return _POSIX_Semaphore_Return_codes[the_semaphore_status]; } 113f91: c9 leave <== NOT EXECUTED 113f92: c3 ret <== NOT EXECUTED 00112870 <_POSIX_Semaphore_Wait_support>: int _POSIX_Semaphore_Wait_support( sem_t *sem, bool blocking, Watchdog_Interval timeout ) { 112870: 55 push %ebp <== NOT EXECUTED 112871: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112873: 53 push %ebx <== NOT EXECUTED 112874: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 112877: 8a 5d 0c mov 0xc(%ebp),%bl <== NOT EXECUTED * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, 11287a: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 11287d: 50 push %eax <== NOT EXECUTED 11287e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 112881: ff 30 pushl (%eax) <== NOT EXECUTED 112883: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 112888: e8 93 c2 ff ff call 10eb20 <_Objects_Get> <== NOT EXECUTED 11288d: 89 c2 mov %eax,%edx <== NOT EXECUTED POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 11288f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112892: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 112895: 85 c9 test %ecx,%ecx <== NOT EXECUTED 112897: 74 17 je 1128b0 <_POSIX_Semaphore_Wait_support+0x40> <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 112899: e8 ea 1b 00 00 call 114488 <__errno> <== NOT EXECUTED 11289e: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1128a4: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 1128a9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1128ac: c9 leave <== NOT EXECUTED 1128ad: c3 ret <== NOT EXECUTED 1128ae: 66 90 xchg %ax,%ax <== NOT EXECUTED the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_semaphore_Seize( 1128b0: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1128b3: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 1128b6: 50 push %eax <== NOT EXECUTED 1128b7: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 1128ba: 8d 42 1c lea 0x1c(%edx),%eax <== NOT EXECUTED 1128bd: 50 push %eax <== NOT EXECUTED 1128be: e8 c5 06 00 00 call 112f88 <_CORE_semaphore_Seize> <== NOT EXECUTED &the_semaphore->Semaphore, the_semaphore->Object.id, blocking, timeout ); _Thread_Enable_dispatch(); 1128c3: e8 9c ca ff ff call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( !_Thread_Executing->Wait.return_code ) 1128c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1128cb: a1 9c 59 12 00 mov 0x12599c,%eax <== NOT EXECUTED 1128d0: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED 1128d3: 85 c0 test %eax,%eax <== NOT EXECUTED 1128d5: 75 09 jne 1128e0 <_POSIX_Semaphore_Wait_support+0x70> <== NOT EXECUTED 1128d7: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 1128d9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1128dc: c9 leave <== NOT EXECUTED 1128dd: c3 ret <== NOT EXECUTED 1128de: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_Enable_dispatch(); if ( !_Thread_Executing->Wait.return_code ) return 0; rtems_set_errno_and_return_minus_one( 1128e0: e8 a3 1b 00 00 call 114488 <__errno> <== NOT EXECUTED 1128e5: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1128e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1128ea: a1 9c 59 12 00 mov 0x12599c,%eax <== NOT EXECUTED 1128ef: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 1128f2: e8 8d 16 00 00 call 113f84 <_POSIX_Semaphore_Translate_core_semaphore_return_code> <== NOT EXECUTED 1128f7: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 1128f9: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1128fe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112901: eb a6 jmp 1128a9 <_POSIX_Semaphore_Wait_support+0x39> <== NOT EXECUTED 0010eedc <_POSIX_Spinlock_Manager_initialization>: */ void _POSIX_Spinlock_Manager_initialization( uint32_t maximum_spinlocks ) { 10eedc: 55 push %ebp <== NOT EXECUTED 10eedd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eedf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10eee2: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10eee7: 6a 01 push $0x1 <== NOT EXECUTED 10eee9: 6a 20 push $0x20 <== NOT EXECUTED 10eeeb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10eeee: 6a 0b push $0xb <== NOT EXECUTED 10eef0: 6a 03 push $0x3 <== NOT EXECUTED 10eef2: 68 c0 fa 11 00 push $0x11fac0 <== NOT EXECUTED 10eef7: e8 70 cc ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10eefc: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10eeff: c9 leave <== NOT EXECUTED 10ef00: c3 ret <== NOT EXECUTED 0010a34c <_POSIX_Spinlock_Translate_core_spinlock_return_code>: int _POSIX_Spinlock_Translate_core_spinlock_return_code( CORE_spinlock_Status the_spinlock_status ) { 10a34c: 55 push %ebp <== NOT EXECUTED 10a34d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a34f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a352: 8b 04 85 e8 a0 11 00 mov 0x11a0e8(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( the_spinlock_status > CORE_SPINLOCK_STATUS_LAST ) return EINVAL; #endif return _POSIX_Spinlock_Return_codes[the_spinlock_status]; } 10a359: c9 leave <== NOT EXECUTED 10a35a: c3 ret <== NOT EXECUTED 0011070c <_POSIX_Thread_Exit>: void _POSIX_Thread_Exit( Thread_Control *the_thread, void *value_ptr ) { 11070c: 55 push %ebp <== NOT EXECUTED 11070d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11070f: 57 push %edi <== NOT EXECUTED 110710: 56 push %esi <== NOT EXECUTED 110711: 53 push %ebx <== NOT EXECUTED 110712: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 110715: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 110718: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Information *the_information; the_information = _Objects_Get_information_id( the_thread->Object.id ); 11071b: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 11071e: e8 25 b3 ff ff call 10ba48 <_Objects_Get_information_id> <== NOT EXECUTED 110723: 89 c6 mov %eax,%esi <== NOT EXECUTED * are ready to be switched out. Otherwise, an ISR could * occur and preempt us out while we still hold the * allocator mutex. */ _RTEMS_Lock_allocator(); 110725: 58 pop %eax <== NOT EXECUTED 110726: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 11072c: e8 37 a6 ff ff call 10ad68 <_API_Mutex_Lock> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 110731: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 110736: 40 inc %eax <== NOT EXECUTED 110737: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED _Thread_Disable_dispatch(); the_thread->Wait.return_argument = value_ptr; 11073c: 89 7b 28 mov %edi,0x28(%ebx) <== NOT EXECUTED _Thread_Close( the_information, the_thread ); 11073f: 5f pop %edi <== NOT EXECUTED 110740: 58 pop %eax <== NOT EXECUTED 110741: 53 push %ebx <== NOT EXECUTED 110742: 56 push %esi <== NOT EXECUTED 110743: e8 e8 b8 ff ff call 10c030 <_Thread_Close> <== NOT EXECUTED * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 110748: 5a pop %edx <== NOT EXECUTED 110749: 59 pop %ecx <== NOT EXECUTED 11074a: 53 push %ebx <== NOT EXECUTED 11074b: 68 80 fa 11 00 push $0x11fa80 <== NOT EXECUTED 110750: e8 7f b2 ff ff call 10b9d4 <_Objects_Free> <== NOT EXECUTED _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 110755: 58 pop %eax <== NOT EXECUTED 110756: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 11075c: e8 4f a6 ff ff call 10adb0 <_API_Mutex_Unlock> <== NOT EXECUTED _Thread_Enable_dispatch(); 110761: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 110764: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 110767: 5b pop %ebx <== NOT EXECUTED 110768: 5e pop %esi <== NOT EXECUTED 110769: 5f pop %edi <== NOT EXECUTED 11076a: c9 leave <== NOT EXECUTED _Thread_Close( the_information, the_thread ); _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); _Thread_Enable_dispatch(); 11076b: e9 dc bb ff ff jmp 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED 0010f00c <_POSIX_Threads_Create_extension>: bool _POSIX_Threads_Create_extension( Thread_Control *executing, Thread_Control *created ) { 10f00c: 55 push %ebp <== NOT EXECUTED 10f00d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f00f: 57 push %edi <== NOT EXECUTED 10f010: 56 push %esi <== NOT EXECUTED 10f011: 53 push %ebx <== NOT EXECUTED 10f012: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED POSIX_API_Control *api; POSIX_API_Control *executing_api; api = _Workspace_Allocate( sizeof( POSIX_API_Control ) ); 10f015: 68 e4 00 00 00 push $0xe4 <== NOT EXECUTED 10f01a: e8 61 e4 ff ff call 10d480 <_Workspace_Allocate> <== NOT EXECUTED 10f01f: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !api ) 10f021: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f024: 85 c0 test %eax,%eax <== NOT EXECUTED 10f026: 0f 84 10 01 00 00 je 10f13c <_POSIX_Threads_Create_extension+0x130> <== NOT EXECUTED return false; created->API_Extensions[ THREAD_API_POSIX ] = api; 10f02c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f02f: 89 98 f8 00 00 00 mov %ebx,0xf8(%eax) <== NOT EXECUTED /* XXX check all fields are touched */ api->Attributes = _POSIX_Threads_Default_attributes; 10f035: be 20 97 11 00 mov $0x119720,%esi <== NOT EXECUTED 10f03a: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 10f03f: 89 df mov %ebx,%edi <== NOT EXECUTED 10f041: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED api->detachstate = _POSIX_Threads_Default_attributes.detachstate; 10f043: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) <== NOT EXECUTED api->schedpolicy = _POSIX_Threads_Default_attributes.schedpolicy; 10f04a: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) <== NOT EXECUTED api->schedparam = _POSIX_Threads_Default_attributes.schedparam; 10f051: be 38 97 11 00 mov $0x119738,%esi <== NOT EXECUTED 10f056: 8d bb 80 00 00 00 lea 0x80(%ebx),%edi <== NOT EXECUTED 10f05c: b1 06 mov $0x6,%cl <== NOT EXECUTED 10f05e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED api->schedparam.sched_priority = 10f060: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10f065: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10f068: 2b 42 14 sub 0x14(%edx),%eax <== NOT EXECUTED 10f06b: 89 83 80 00 00 00 mov %eax,0x80(%ebx) <== NOT EXECUTED _POSIX_Priority_From_core( created->current_priority ); /* * POSIX 1003.1 1996, 18.2.2.2 */ api->cancelation_requested = 0; 10f071: c7 83 d4 00 00 00 00 movl $0x0,0xd4(%ebx) <== NOT EXECUTED 10f078: 00 00 00 <== NOT EXECUTED api->cancelability_state = PTHREAD_CANCEL_ENABLE; 10f07b: c7 83 cc 00 00 00 00 movl $0x0,0xcc(%ebx) <== NOT EXECUTED 10f082: 00 00 00 <== NOT EXECUTED api->cancelability_type = PTHREAD_CANCEL_DEFERRED; 10f085: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) <== NOT EXECUTED 10f08c: 00 00 00 <== NOT EXECUTED 10f08f: 8d 83 dc 00 00 00 lea 0xdc(%ebx),%eax <== NOT EXECUTED 10f095: 89 83 d8 00 00 00 mov %eax,0xd8(%ebx) <== NOT EXECUTED 10f09b: c7 83 dc 00 00 00 00 movl $0x0,0xdc(%ebx) <== NOT EXECUTED 10f0a2: 00 00 00 <== NOT EXECUTED 10f0a5: 8d 83 d8 00 00 00 lea 0xd8(%ebx),%eax <== NOT EXECUTED 10f0ab: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx) <== NOT EXECUTED * If the thread is not a posix thread, then all posix signals are blocked * by default. */ /* XXX use signal constants */ api->signals_pending = 0; 10f0b1: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED 10f0b8: 00 00 00 <== NOT EXECUTED if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API && 10f0bb: 8b 52 08 mov 0x8(%edx),%edx <== NOT EXECUTED 10f0be: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f0c0: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10f0c3: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10f0c6: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10f0c9: 74 51 je 10f11c <_POSIX_Threads_Create_extension+0x110> <== NOT EXECUTED _Objects_Get_class( created->Object.id ) == 1 ) { executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; api->signals_blocked = executing_api->signals_blocked; } else { api->signals_blocked = 0xffffffff; 10f0cb: c7 83 c4 00 00 00 ff movl $0xffffffff,0xc4(%ebx) <== NOT EXECUTED 10f0d2: ff ff ff <== NOT EXECUTED } _Thread_queue_Initialize( 10f0d5: 6a 00 push $0x0 <== NOT EXECUTED 10f0d7: 68 00 10 00 00 push $0x1000 <== NOT EXECUTED 10f0dc: 6a 00 push $0x0 <== NOT EXECUTED 10f0de: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10f0e1: 50 push %eax <== NOT EXECUTED 10f0e2: e8 99 d9 ff ff call 10ca80 <_Thread_queue_Initialize> <== NOT EXECUTED THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_JOIN_AT_EXIT, 0 ); _Watchdog_Initialize( 10f0e7: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10f0ea: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10f0ed: c7 83 a4 00 00 00 00 movl $0x0,0xa4(%ebx) <== NOT EXECUTED 10f0f4: 00 00 00 <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10f0f7: c7 83 b8 00 00 00 88 movl $0x10f188,0xb8(%ebx) <== NOT EXECUTED 10f0fe: f1 10 00 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10f101: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) <== NOT EXECUTED * the heap 10f107: 89 93 c0 00 00 00 mov %edx,0xc0(%ebx) <== NOT EXECUTED 10f10d: b0 01 mov $0x1,%al <== NOT EXECUTED 10f10f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED created->Object.id, created ); return true; } 10f112: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f115: 5b pop %ebx <== NOT EXECUTED 10f116: 5e pop %esi <== NOT EXECUTED 10f117: 5f pop %edi <== NOT EXECUTED 10f118: c9 leave <== NOT EXECUTED 10f119: c3 ret <== NOT EXECUTED 10f11a: 66 90 xchg %ax,%ax <== NOT EXECUTED * by default. */ /* XXX use signal constants */ api->signals_pending = 0; if ( _Objects_Get_API( created->Object.id ) == OBJECTS_POSIX_API && 10f11c: c1 ea 1b shr $0x1b,%edx <== NOT EXECUTED 10f11f: 4a dec %edx <== NOT EXECUTED 10f120: 75 a9 jne 10f0cb <_POSIX_Threads_Create_extension+0xbf> <== NOT EXECUTED _Objects_Get_class( created->Object.id ) == 1 ) { executing_api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; api->signals_blocked = executing_api->signals_blocked; 10f122: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED 10f127: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED 10f12d: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 10f133: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx) <== NOT EXECUTED 10f139: eb 9a jmp 10f0d5 <_POSIX_Threads_Create_extension+0xc9> <== NOT EXECUTED 10f13b: 90 nop <== NOT EXECUTED POSIX_API_Control *api; POSIX_API_Control *executing_api; api = _Workspace_Allocate( sizeof( POSIX_API_Control ) ); if ( !api ) 10f13c: 31 c0 xor %eax,%eax <== NOT EXECUTED created->Object.id, created ); return true; } 10f13e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f141: 5b pop %ebx <== NOT EXECUTED 10f142: 5e pop %esi <== NOT EXECUTED 10f143: 5f pop %edi <== NOT EXECUTED 10f144: c9 leave <== NOT EXECUTED 10f145: c3 ret <== NOT EXECUTED 0010ef88 <_POSIX_Threads_Delete_extension>: User_extensions_routine _POSIX_Threads_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 10ef88: 55 push %ebp <== NOT EXECUTED 10ef89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ef8b: 57 push %edi <== NOT EXECUTED 10ef8c: 56 push %esi <== NOT EXECUTED 10ef8d: 53 push %ebx <== NOT EXECUTED 10ef8e: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10ef91: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Thread_Control *the_thread; POSIX_API_Control *api; void **value_ptr; api = deleted->API_Extensions[ THREAD_API_POSIX ]; 10ef94: 8b 87 f8 00 00 00 mov 0xf8(%edi),%eax <== NOT EXECUTED 10ef9a: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED /* * Run the POSIX cancellation handlers */ _POSIX_Threads_cancel_run( deleted ); 10ef9d: 57 push %edi <== NOT EXECUTED 10ef9e: e8 a1 14 00 00 call 110444 <_POSIX_Threads_cancel_run> <== NOT EXECUTED /* * Run all the key destructors */ _POSIX_Keys_Run_destructors( deleted ); 10efa3: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10efa6: e8 fd 14 00 00 call 1104a8 <_POSIX_Keys_Run_destructors> <== NOT EXECUTED /* * Wakeup all the tasks which joined with this one */ value_ptr = (void **) deleted->Wait.return_argument; 10efab: 8b 77 28 mov 0x28(%edi),%esi <== NOT EXECUTED while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) 10efae: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 10efb1: 83 c3 3c add $0x3c,%ebx <== NOT EXECUTED 10efb4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10efb7: eb 08 jmp 10efc1 <_POSIX_Threads_Delete_extension+0x39> <== NOT EXECUTED 10efb9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED *(void **)the_thread->Wait.return_argument = value_ptr; 10efbc: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 10efbf: 89 30 mov %esi,(%eax) <== NOT EXECUTED /* * Wakeup all the tasks which joined with this one */ value_ptr = (void **) deleted->Wait.return_argument; while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) 10efc1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10efc4: 53 push %ebx <== NOT EXECUTED 10efc5: e8 06 d7 ff ff call 10c6d0 <_Thread_queue_Dequeue> <== NOT EXECUTED 10efca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10efcd: 85 c0 test %eax,%eax <== NOT EXECUTED 10efcf: 75 eb jne 10efbc <_POSIX_Threads_Delete_extension+0x34> <== NOT EXECUTED *(void **)the_thread->Wait.return_argument = value_ptr; if ( api->schedpolicy == SCHED_SPORADIC ) 10efd1: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10efd4: 83 78 7c 03 cmpl $0x3,0x7c(%eax) <== NOT EXECUTED 10efd8: 74 1e je 10eff8 <_POSIX_Threads_Delete_extension+0x70> <== NOT EXECUTED (void) _Watchdog_Remove( &api->Sporadic_timer ); deleted->API_Extensions[ THREAD_API_POSIX ] = NULL; 10efda: c7 87 f8 00 00 00 00 movl $0x0,0xf8(%edi) <== NOT EXECUTED 10efe1: 00 00 00 <== NOT EXECUTED (void) _Workspace_Free( api ); 10efe4: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10efe7: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10efea: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10efed: 5b pop %ebx <== NOT EXECUTED 10efee: 5e pop %esi <== NOT EXECUTED 10efef: 5f pop %edi <== NOT EXECUTED 10eff0: c9 leave <== NOT EXECUTED if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); deleted->API_Extensions[ THREAD_API_POSIX ] = NULL; (void) _Workspace_Free( api ); 10eff1: e9 72 e4 ff ff jmp 10d468 <_Workspace_Free> <== NOT EXECUTED 10eff6: 66 90 xchg %ax,%ax <== NOT EXECUTED while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) ) *(void **)the_thread->Wait.return_argument = value_ptr; if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); 10eff8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10effb: 05 9c 00 00 00 add $0x9c,%eax <== NOT EXECUTED 10f000: 50 push %eax <== NOT EXECUTED 10f001: e8 86 e3 ff ff call 10d38c <_Watchdog_Remove> <== NOT EXECUTED 10f006: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f009: eb cf jmp 10efda <_POSIX_Threads_Delete_extension+0x52> <== NOT EXECUTED 0010ef68 <_POSIX_Threads_Exitted_extension>: */ User_extensions_routine _POSIX_Threads_Exitted_extension( Thread_Control *executing ) { 10ef68: 55 push %ebp <== NOT EXECUTED 10ef69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ef6b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED /* * If the executing thread was not created with the POSIX API, then this * API do not get to define its exit behavior. */ if ( _Objects_Get_API( executing->Object.id ) == OBJECTS_POSIX_API ) 10ef6e: 0f b6 42 0b movzbl 0xb(%edx),%eax <== NOT EXECUTED 10ef72: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10ef75: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10ef78: 74 02 je 10ef7c <_POSIX_Threads_Exitted_extension+0x14> <== NOT EXECUTED pthread_exit( executing->Wait.return_argument ); } 10ef7a: c9 leave <== NOT EXECUTED 10ef7b: c3 ret <== NOT EXECUTED /* * If the executing thread was not created with the POSIX API, then this * API do not get to define its exit behavior. */ if ( _Objects_Get_API( executing->Object.id ) == OBJECTS_POSIX_API ) pthread_exit( executing->Wait.return_argument ); 10ef7c: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 10ef7f: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10ef82: c9 leave <== NOT EXECUTED /* * If the executing thread was not created with the POSIX API, then this * API do not get to define its exit behavior. */ if ( _Objects_Get_API( executing->Object.id ) == OBJECTS_POSIX_API ) pthread_exit( executing->Wait.return_argument ); 10ef83: e9 e8 17 00 00 jmp 110770 <== NOT EXECUTED 0010ef04 <_POSIX_Threads_Initialize_user_threads>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads( void ) { 10ef04: 55 push %ebp <== NOT EXECUTED 10ef05: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( _POSIX_Threads_Initialize_user_threads_p ) 10ef07: 8b 0d 54 db 11 00 mov 0x11db54,%ecx <== NOT EXECUTED 10ef0d: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ef0f: 74 03 je 10ef14 <_POSIX_Threads_Initialize_user_threads+0x10> <== NOT EXECUTED (*_POSIX_Threads_Initialize_user_threads_p)(); } 10ef11: c9 leave <== NOT EXECUTED */ void _POSIX_Threads_Initialize_user_threads( void ) { if ( _POSIX_Threads_Initialize_user_threads_p ) (*_POSIX_Threads_Initialize_user_threads_p)(); 10ef12: ff e1 jmp *%ecx <== NOT EXECUTED } 10ef14: c9 leave <== NOT EXECUTED 10ef15: c3 ret <== NOT EXECUTED 0010b068 <_POSIX_Threads_Initialize_user_threads_body>: * * Output parameters: NONE */ void _POSIX_Threads_Initialize_user_threads_body( void ) { 10b068: 55 push %ebp <== NOT EXECUTED 10b069: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b06b: 57 push %edi <== NOT EXECUTED 10b06c: 56 push %esi <== NOT EXECUTED 10b06d: 53 push %ebx <== NOT EXECUTED 10b06e: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED uint32_t maximum; posix_initialization_threads_table *user_threads; pthread_t thread_id; pthread_attr_t attr; user_threads = _POSIX_Threads_User_initialization_threads; 10b071: 8b 3d 40 38 12 00 mov 0x123840,%edi <== NOT EXECUTED maximum = _POSIX_Threads_Number_of_initialization_threads; 10b077: a1 14 39 12 00 mov 0x123914,%eax <== NOT EXECUTED 10b07c: 89 45 b0 mov %eax,-0x50(%ebp) <== NOT EXECUTED if ( !user_threads || maximum == 0 ) 10b07f: 85 ff test %edi,%edi <== NOT EXECUTED 10b081: 74 44 je 10b0c7 <_POSIX_Threads_Initialize_user_threads_body+0x5f> <== NOT EXECUTED 10b083: 85 c0 test %eax,%eax <== NOT EXECUTED 10b085: 74 40 je 10b0c7 <_POSIX_Threads_Initialize_user_threads_body+0x5f> <== NOT EXECUTED 10b087: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b089: 8d 75 b8 lea -0x48(%ebp),%esi <== NOT EXECUTED for ( index=0 ; index < maximum ; index++ ) { /* * There is no way for these calls to fail in this situation. */ (void) pthread_attr_init( &attr ); 10b08c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b08f: 56 push %esi <== NOT EXECUTED 10b090: e8 cb 5d 00 00 call 110e60 <== NOT EXECUTED (void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED ); 10b095: 58 pop %eax <== NOT EXECUTED 10b096: 5a pop %edx <== NOT EXECUTED 10b097: 6a 02 push $0x2 <== NOT EXECUTED 10b099: 56 push %esi <== NOT EXECUTED 10b09a: e8 f1 5d 00 00 call 110e90 <== NOT EXECUTED (void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size); 10b09f: 59 pop %ecx <== NOT EXECUTED 10b0a0: 58 pop %eax <== NOT EXECUTED 10b0a1: ff 74 df 04 pushl 0x4(%edi,%ebx,8) <== NOT EXECUTED 10b0a5: 56 push %esi <== NOT EXECUTED 10b0a6: e8 19 5e 00 00 call 110ec4 <== NOT EXECUTED status = pthread_create( 10b0ab: 6a 00 push $0x0 <== NOT EXECUTED 10b0ad: ff 34 df pushl (%edi,%ebx,8) <== NOT EXECUTED 10b0b0: 56 push %esi <== NOT EXECUTED 10b0b1: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b0b4: 50 push %eax <== NOT EXECUTED 10b0b5: e8 ea fb ff ff call 10aca4 <== NOT EXECUTED &thread_id, &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) 10b0ba: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10b0bd: 85 c0 test %eax,%eax <== NOT EXECUTED 10b0bf: 75 0f jne 10b0d0 <_POSIX_Threads_Initialize_user_threads_body+0x68> <== 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++ ) { 10b0c1: 43 inc %ebx <== NOT EXECUTED 10b0c2: 39 5d b0 cmp %ebx,-0x50(%ebp) <== NOT EXECUTED 10b0c5: 77 c5 ja 10b08c <_POSIX_Threads_Initialize_user_threads_body+0x24> <== NOT EXECUTED NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, status ); } } 10b0c7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b0ca: 5b pop %ebx <== NOT EXECUTED 10b0cb: 5e pop %esi <== NOT EXECUTED 10b0cc: 5f pop %edi <== NOT EXECUTED 10b0cd: c9 leave <== NOT EXECUTED 10b0ce: c3 ret <== NOT EXECUTED 10b0cf: 90 nop <== NOT EXECUTED &attr, user_threads[ index ].thread_entry, NULL ); if ( status ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, status ); 10b0d0: 52 push %edx <== NOT EXECUTED 10b0d1: 50 push %eax <== NOT EXECUTED 10b0d2: 6a 01 push $0x1 <== NOT EXECUTED 10b0d4: 6a 02 push $0x2 <== NOT EXECUTED 10b0d6: e8 31 21 00 00 call 10d20c <_Internal_error_Occurred> <== NOT EXECUTED 0010ef18 <_POSIX_Threads_Manager_initialization>: uint32_t maximum_pthreads, uint32_t number_of_initialization_threads, posix_initialization_threads_table *user_threads ) { 10ef18: 55 push %ebp <== NOT EXECUTED 10ef19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ef1b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _POSIX_Threads_Number_of_initialization_threads = 10ef1e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ef21: a3 14 fd 11 00 mov %eax,0x11fd14 <== NOT EXECUTED number_of_initialization_threads; _POSIX_Threads_User_initialization_threads = user_threads; 10ef26: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10ef29: a3 40 fc 11 00 mov %eax,0x11fc40 <== NOT EXECUTED #if 0 if ( user_threads == NULL || number_of_initialization_threads == 0 ) _Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, TRUE, EINVAL ); #endif _Objects_Initialize_information( 10ef2e: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10ef33: 6a 01 push $0x1 <== NOT EXECUTED 10ef35: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10ef3a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ef3d: 6a 01 push $0x1 <== NOT EXECUTED 10ef3f: 6a 03 push $0x3 <== NOT EXECUTED 10ef41: 68 80 fa 11 00 push $0x11fa80 <== NOT EXECUTED 10ef46: e8 21 cc ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED /* * Add all the extensions for this API */ _User_extensions_Add_API_set( &_POSIX_Threads_User_extensions ); 10ef4b: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10ef4e: 68 a0 d5 11 00 push $0x11d5a0 <== NOT EXECUTED 10ef53: e8 0c 10 00 00 call 10ff64 <_User_extensions_Add_API_set> <== NOT EXECUTED _API_extensions_Add( &_POSIX_Threads_API_extensions ); 10ef58: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ef5b: c7 45 08 80 d5 11 00 movl $0x11d580,0x8(%ebp) <== NOT EXECUTED /* * If we supported MP, then here we would ... * Register the MP Process Packet routine. */ } 10ef62: c9 leave <== NOT EXECUTED * Add all the extensions for this API */ _User_extensions_Add_API_set( &_POSIX_Threads_User_extensions ); _API_extensions_Add( &_POSIX_Threads_API_extensions ); 10ef63: e9 8c bd ff ff jmp 10acf4 <_API_extensions_Add> <== NOT EXECUTED 0010f188 <_POSIX_Threads_Sporadic_budget_TSR>: void _POSIX_Threads_Sporadic_budget_TSR( Objects_Id id, void *argument ) { 10f188: 55 push %ebp <== NOT EXECUTED 10f189: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f18b: 56 push %esi <== NOT EXECUTED 10f18c: 53 push %ebx <== NOT EXECUTED 10f18d: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Thread_Control *the_thread; POSIX_API_Control *api; the_thread = argument; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10f190: 8b b3 f8 00 00 00 mov 0xf8(%ebx),%esi <== NOT EXECUTED ticks = _Timespec_To_ticks( &api->schedparam.ss_initial_budget ); 10f196: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f199: 8d 86 90 00 00 00 lea 0x90(%esi),%eax <== NOT EXECUTED 10f19f: 50 push %eax <== NOT EXECUTED 10f1a0: e8 5b 0d 00 00 call 10ff00 <_Timespec_To_ticks> <== NOT EXECUTED if ( !ticks ) 10f1a5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f1a8: 85 c0 test %eax,%eax <== NOT EXECUTED 10f1aa: 75 02 jne 10f1ae <_POSIX_Threads_Sporadic_budget_TSR+0x26> <== NOT EXECUTED 10f1ac: b0 01 mov $0x1,%al <== NOT EXECUTED ticks = 1; the_thread->cpu_time_budget = ticks; 10f1ae: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10f1b1: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10f1b6: 2b 86 98 00 00 00 sub 0x98(%esi),%eax <== NOT EXECUTED new_priority = _POSIX_Priority_To_core( api->ss_high_priority ); the_thread->real_priority = new_priority; 10f1bc: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED if ( the_thread->resource_count == 0 || 10f1bf: 8b 4b 1c mov 0x1c(%ebx),%ecx <== NOT EXECUTED 10f1c2: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f1c4: 74 3e je 10f204 <_POSIX_Threads_Sporadic_budget_TSR+0x7c> <== NOT EXECUTED 10f1c6: 39 43 14 cmp %eax,0x14(%ebx) <== NOT EXECUTED 10f1c9: 77 39 ja 10f204 <_POSIX_Threads_Sporadic_budget_TSR+0x7c> <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); ticks = _Timespec_To_ticks( &api->schedparam.ss_replenish_period ); 10f1cb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f1ce: 8d 86 88 00 00 00 lea 0x88(%esi),%eax <== NOT EXECUTED 10f1d4: 50 push %eax <== NOT EXECUTED 10f1d5: e8 26 0d 00 00 call 10ff00 <_Timespec_To_ticks> <== NOT EXECUTED if ( !ticks ) 10f1da: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f1dd: 85 c0 test %eax,%eax <== NOT EXECUTED 10f1df: 75 02 jne 10f1e3 <_POSIX_Threads_Sporadic_budget_TSR+0x5b> <== NOT EXECUTED 10f1e1: b0 01 mov $0x1,%al <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10f1e3: 89 86 a8 00 00 00 mov %eax,0xa8(%esi) <== NOT EXECUTED void *starting_address, size_t *size 10f1e9: 8d 86 9c 00 00 00 lea 0x9c(%esi),%eax <== NOT EXECUTED 10f1ef: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10f1f2: c7 45 08 9c f8 11 00 movl $0x11f89c,0x8(%ebp) <== NOT EXECUTED ticks = 1; _Watchdog_Insert_ticks( &api->Sporadic_timer, ticks ); } 10f1f9: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f1fc: 5b pop %ebx <== NOT EXECUTED 10f1fd: 5e pop %esi <== NOT EXECUTED 10f1fe: c9 leave <== NOT EXECUTED 10f1ff: e9 58 e0 ff ff jmp 10d25c <_Watchdog_Insert> <== NOT EXECUTED 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 ); 10f204: 52 push %edx <== NOT EXECUTED 10f205: 6a 01 push $0x1 <== NOT EXECUTED 10f207: 50 push %eax <== NOT EXECUTED 10f208: 53 push %ebx <== NOT EXECUTED 10f209: e8 62 cc ff ff call 10be70 <_Thread_Change_priority> <== NOT EXECUTED 10f20e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f211: eb b8 jmp 10f1cb <_POSIX_Threads_Sporadic_budget_TSR+0x43> <== NOT EXECUTED 0010f148 <_POSIX_Threads_Sporadic_budget_callout>: */ void _POSIX_Threads_Sporadic_budget_callout( Thread_Control *the_thread ) { 10f148: 55 push %ebp <== NOT EXECUTED 10f149: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f14b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f14e: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED POSIX_API_Control *api; uint32_t new_priority; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10f151: 8b 81 f8 00 00 00 mov 0xf8(%ecx),%eax <== NOT EXECUTED * 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 */ 10f157: c7 41 78 ff ff ff ff movl $0xffffffff,0x78(%ecx) <== NOT EXECUTED /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of 10f15e: ba ff 00 00 00 mov $0xff,%edx <== NOT EXECUTED 10f163: 2b 90 84 00 00 00 sub 0x84(%eax),%edx <== NOT EXECUTED new_priority = _POSIX_Priority_To_core( api->schedparam.ss_low_priority ); the_thread->real_priority = new_priority; 10f169: 89 51 18 mov %edx,0x18(%ecx) <== NOT EXECUTED if ( the_thread->resource_count == 0 || 10f16c: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 10f16f: 85 c0 test %eax,%eax <== NOT EXECUTED 10f171: 74 05 je 10f178 <_POSIX_Threads_Sporadic_budget_callout+0x30> <== NOT EXECUTED 10f173: 39 51 14 cmp %edx,0x14(%ecx) <== NOT EXECUTED 10f176: 76 0d jbe 10f185 <_POSIX_Threads_Sporadic_budget_callout+0x3d> <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, TRUE ); 10f178: 50 push %eax <== NOT EXECUTED 10f179: 6a 01 push $0x1 <== NOT EXECUTED 10f17b: 52 push %edx <== NOT EXECUTED 10f17c: 51 push %ecx <== NOT EXECUTED 10f17d: e8 ee cc ff ff call 10be70 <_Thread_Change_priority> <== NOT EXECUTED 10f182: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10f185: c9 leave <== NOT EXECUTED 10f186: c3 ret <== NOT EXECUTED 00110444 <_POSIX_Threads_cancel_run>: #include void _POSIX_Threads_cancel_run( Thread_Control *the_thread ) { 110444: 55 push %ebp <== NOT EXECUTED 110445: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110447: 57 push %edi <== NOT EXECUTED 110448: 56 push %esi <== NOT EXECUTED 110449: 53 push %ebx <== NOT EXECUTED 11044a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 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 ]; 11044d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 110450: 8b b8 f8 00 00 00 mov 0xf8(%eax),%edi <== NOT EXECUTED handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; 110456: c7 87 cc 00 00 00 01 movl $0x1,0xcc(%edi) <== NOT EXECUTED 11045d: 00 00 00 <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 110460: 8d b7 dc 00 00 00 lea 0xdc(%edi),%esi <== NOT EXECUTED while ( !_Chain_Is_empty( handler_stack ) ) { 110466: 39 b7 d8 00 00 00 cmp %esi,0xd8(%edi) <== NOT EXECUTED 11046c: 74 30 je 11049e <_POSIX_Threads_cancel_run+0x5a> <== NOT EXECUTED 11046e: 66 90 xchg %ax,%ax <== NOT EXECUTED _ISR_Disable( level ); 110470: 9c pushf <== NOT EXECUTED 110471: fa cli <== NOT EXECUTED 110472: 59 pop %ecx <== NOT EXECUTED handler = (POSIX_Cancel_Handler_control *) 110473: 8b 5e 04 mov 0x4(%esi),%ebx <== NOT EXECUTED 110476: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 110478: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 11047b: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 11047e: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 110480: 51 push %ecx <== NOT EXECUTED 110481: 9d popf <== NOT EXECUTED (*handler->routine)( handler->arg ); 110482: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110485: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 110488: ff 53 08 call *0x8(%ebx) <== NOT EXECUTED _Workspace_Free( handler ); 11048b: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 11048e: e8 d5 cf ff ff call 10d468 <_Workspace_Free> <== NOT EXECUTED handler_stack = &thread_support->Cancellation_Handlers; thread_support->cancelability_state = PTHREAD_CANCEL_DISABLE; while ( !_Chain_Is_empty( handler_stack ) ) { 110493: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110496: 39 b7 d8 00 00 00 cmp %esi,0xd8(%edi) <== NOT EXECUTED 11049c: 75 d2 jne 110470 <_POSIX_Threads_cancel_run+0x2c> <== NOT EXECUTED (*handler->routine)( handler->arg ); _Workspace_Free( handler ); } } 11049e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1104a1: 5b pop %ebx <== NOT EXECUTED 1104a2: 5e pop %esi <== NOT EXECUTED 1104a3: 5f pop %edi <== NOT EXECUTED 1104a4: c9 leave <== NOT EXECUTED 1104a5: c3 ret <== NOT EXECUTED 0011120c <_POSIX_Timer_Insert_helper>: Watchdog_Interval ticks, Objects_Id id, Watchdog_Service_routine_entry TSR, void *arg ) { 11120c: 55 push %ebp <== NOT EXECUTED 11120d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11120f: 56 push %esi <== NOT EXECUTED 111210: 53 push %ebx <== NOT EXECUTED 111211: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; (void) _Watchdog_Remove( timer ); 111214: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111217: 53 push %ebx <== NOT EXECUTED 111218: e8 bf de ff ff call 10f0dc <_Watchdog_Remove> <== NOT EXECUTED _ISR_Disable( level ); 11121d: 9c pushf <== NOT EXECUTED 11121e: fa cli <== NOT EXECUTED 11121f: 5e pop %esi <== NOT EXECUTED /* * 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 ) { 111220: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111223: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 111226: 85 c0 test %eax,%eax <== NOT EXECUTED 111228: 74 0e je 111238 <_POSIX_Timer_Insert_helper+0x2c> <== NOT EXECUTED _ISR_Enable( level ); 11122a: 56 push %esi <== NOT EXECUTED 11122b: 9d popf <== NOT EXECUTED 11122c: 31 c0 xor %eax,%eax <== NOT EXECUTED */ _Watchdog_Initialize( timer, TSR, id, arg ); _Watchdog_Insert_ticks( timer, ticks ); _ISR_Enable( level ); return true; } 11122e: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111231: 5b pop %ebx <== NOT EXECUTED 111232: 5e pop %esi <== NOT EXECUTED 111233: c9 leave <== NOT EXECUTED 111234: c3 ret <== NOT EXECUTED 111235: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 111238: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 11123f: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 111242: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 111245: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 111248: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED * the heap 11124b: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 11124e: 89 43 24 mov %eax,0x24(%ebx) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 111251: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 111254: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 111257: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11125a: 53 push %ebx <== NOT EXECUTED 11125b: 68 1c 3f 12 00 push $0x123f1c <== NOT EXECUTED 111260: e8 47 dd ff ff call 10efac <_Watchdog_Insert> <== NOT EXECUTED * 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 ); 111265: 56 push %esi <== NOT EXECUTED 111266: 9d popf <== NOT EXECUTED 111267: b0 01 mov $0x1,%al <== NOT EXECUTED 111269: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return true; } 11126c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11126f: 5b pop %ebx <== NOT EXECUTED 111270: 5e pop %esi <== NOT EXECUTED 111271: c9 leave <== NOT EXECUTED 111272: c3 ret <== NOT EXECUTED 0010f214 <_POSIX_Timer_Manager_initialization>: * Description: Initialize the internal structure in which the data of all * the timers are stored */ void _POSIX_Timer_Manager_initialization ( int maximum_timers ) { 10f214: 55 push %ebp <== NOT EXECUTED 10f215: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f217: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f21a: 68 ff 00 00 00 push $0xff <== NOT EXECUTED 10f21f: 6a 01 push $0x1 <== NOT EXECUTED 10f221: 6a 74 push $0x74 <== NOT EXECUTED 10f223: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f226: 6a 09 push $0x9 <== NOT EXECUTED 10f228: 6a 03 push $0x3 <== NOT EXECUTED 10f22a: 68 40 fb 11 00 push $0x11fb40 <== NOT EXECUTED 10f22f: e8 38 c9 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f234: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10f237: c9 leave <== NOT EXECUTED 10f238: c3 ret <== NOT EXECUTED 0010b760 <_POSIX_Timer_TSR>: /* * This is the operation that is run when a timer expires */ void _POSIX_Timer_TSR(Objects_Id timer, void *data) { 10b760: 55 push %ebp <== NOT EXECUTED 10b761: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b763: 53 push %ebx <== NOT EXECUTED 10b764: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b767: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED bool activated; ptimer = (POSIX_Timer_Control *)data; /* Increment the number of expirations. */ ptimer->overrun = ptimer->overrun + 1; 10b76a: ff 43 68 incl 0x68(%ebx) <== NOT EXECUTED /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || 10b76d: 8b 53 54 mov 0x54(%ebx),%edx <== NOT EXECUTED 10b770: 85 d2 test %edx,%edx <== NOT EXECUTED 10b772: 75 28 jne 10b79c <_POSIX_Timer_TSR+0x3c> <== NOT EXECUTED 10b774: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED 10b777: 85 c0 test %eax,%eax <== NOT EXECUTED 10b779: 75 21 jne 10b79c <_POSIX_Timer_TSR+0x3c> <== 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; 10b77b: c6 43 3c 04 movb $0x4,0x3c(%ebx) <== 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 ) ) { 10b77f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b782: ff 73 44 pushl 0x44(%ebx) <== NOT EXECUTED 10b785: ff 73 38 pushl 0x38(%ebx) <== NOT EXECUTED 10b788: e8 83 57 00 00 call 110f10 <== NOT EXECUTED } /* After the signal handler returns, the count of expirations of the * timer must be set to 0. */ ptimer->overrun = 0; 10b78d: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) <== NOT EXECUTED 10b794: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b797: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b79a: c9 leave <== NOT EXECUTED 10b79b: c3 ret <== NOT EXECUTED ptimer->overrun = ptimer->overrun + 1; /* The timer must be reprogrammed */ if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) || ( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) { activated = _POSIX_Timer_Insert_helper( 10b79c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b79f: 53 push %ebx <== NOT EXECUTED 10b7a0: 68 60 b7 10 00 push $0x10b760 <== NOT EXECUTED 10b7a5: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10b7a8: ff 73 64 pushl 0x64(%ebx) <== NOT EXECUTED 10b7ab: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10b7ae: 50 push %eax <== NOT EXECUTED 10b7af: e8 58 5a 00 00 call 11120c <_POSIX_Timer_Insert_helper> <== NOT EXECUTED ptimer->ticks, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) 10b7b4: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10b7b7: 84 c0 test %al,%al <== NOT EXECUTED 10b7b9: 74 dc je 10b797 <_POSIX_Timer_TSR+0x37> <== NOT EXECUTED return; /* Store the time when the timer was started again */ _TOD_Get( &ptimer->time ); 10b7bb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b7be: 8d 43 6c lea 0x6c(%ebx),%eax <== NOT EXECUTED 10b7c1: 50 push %eax <== NOT EXECUTED 10b7c2: e8 19 17 00 00 call 10cee0 <_TOD_Get> <== NOT EXECUTED /* The state really did not change but just to be safe */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10b7c7: c6 43 3c 03 movb $0x3,0x3c(%ebx) <== NOT EXECUTED 10b7cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b7ce: eb af jmp 10b77f <_POSIX_Timer_TSR+0x1f> <== NOT EXECUTED 0010eecc <_POSIX_signals_Abnormal_termination_handler>: /*** PROCESS WIDE STUFF ****/ sigset_t _POSIX_signals_Pending; void _POSIX_signals_Abnormal_termination_handler( int signo ) { 10eecc: 55 push %ebp <== NOT EXECUTED 10eecd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eecf: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED exit( 1 ); 10eed2: 6a 01 push $0x1 <== NOT EXECUTED 10eed4: e8 b3 1d 00 00 call 110c8c <== NOT EXECUTED 0010bcb8 <_POSIX_signals_Alarm_TSR>: void _POSIX_signals_Alarm_TSR( Objects_Id id, void *argument ) { 10bcb8: 55 push %ebp <== NOT EXECUTED 10bcb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bcbb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED int status; status = kill( getpid(), SIGALRM ); 10bcbe: e8 89 d5 ff ff call 10924c <== NOT EXECUTED 10bcc3: c7 45 0c 0e 00 00 00 movl $0xe,0xc(%ebp) <== NOT EXECUTED 10bcca: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED /* XXX can't print from an ISR, should this be fatal? */ } 10bccd: c9 leave <== NOT EXECUTED void *argument ) { int status; status = kill( getpid(), SIGALRM ); 10bcce: e9 71 00 00 00 jmp 10bd44 <== NOT EXECUTED 00110550 <_POSIX_signals_Check_signal>: bool _POSIX_signals_Check_signal( POSIX_API_Control *api, int signo, bool is_global ) { 110550: 55 push %ebp <== NOT EXECUTED 110551: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110553: 57 push %edi <== NOT EXECUTED 110554: 56 push %esi <== NOT EXECUTED 110555: 53 push %ebx <== NOT EXECUTED 110556: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 110559: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 11055c: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED siginfo_t siginfo_struct; sigset_t saved_signals_blocked; if ( ! _POSIX_signals_Clear_signals( api, signo, &siginfo_struct, 11055f: 6a 01 push $0x1 <== NOT EXECUTED 110561: 0f b6 45 10 movzbl 0x10(%ebp),%eax <== NOT EXECUTED 110565: 50 push %eax <== NOT EXECUTED 110566: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 110569: 50 push %eax <== NOT EXECUTED 11056a: 53 push %ebx <== NOT EXECUTED 11056b: 56 push %esi <== NOT EXECUTED 11056c: e8 73 00 00 00 call 1105e4 <_POSIX_signals_Clear_signals> <== NOT EXECUTED 110571: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 110574: 84 c0 test %al,%al <== NOT EXECUTED 110576: 74 4c je 1105c4 <_POSIX_signals_Check_signal+0x74> <== NOT EXECUTED #endif /* * Just to prevent sending a signal which is currently being ignored. */ if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN ) 110578: 8d 04 5b lea (%ebx,%ebx,2),%eax <== NOT EXECUTED 11057b: 8d 14 85 00 00 00 00 lea 0x0(,%eax,4),%edx <== NOT EXECUTED 110582: 8b 8a 08 fe 11 00 mov 0x11fe08(%edx),%ecx <== NOT EXECUTED 110588: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED 11058b: 74 37 je 1105c4 <_POSIX_signals_Check_signal+0x74> <== NOT EXECUTED return false; /* * Block the signals requested in sa_mask */ saved_signals_blocked = api->signals_blocked; 11058d: 8b be c4 00 00 00 mov 0xc4(%esi),%edi <== NOT EXECUTED api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask; 110593: 89 f8 mov %edi,%eax <== NOT EXECUTED 110595: 0b 82 04 fe 11 00 or 0x11fe04(%edx),%eax <== NOT EXECUTED 11059b: 89 86 c4 00 00 00 mov %eax,0xc4(%esi) <== NOT EXECUTED /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { 1105a1: 83 ba 00 fe 11 00 02 cmpl $0x2,0x11fe00(%edx) <== NOT EXECUTED 1105a8: 74 26 je 1105d0 <_POSIX_signals_Check_signal+0x80> <== NOT EXECUTED &siginfo_struct, NULL /* context is undefined per 1003.1b-1993, p. 66 */ ); break; default: (*_POSIX_signals_Vectors[ signo ].sa_handler)( signo ); 1105aa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1105ad: 53 push %ebx <== NOT EXECUTED 1105ae: ff d1 call *%ecx <== NOT EXECUTED 1105b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; 1105b3: 89 be c4 00 00 00 mov %edi,0xc4(%esi) <== NOT EXECUTED 1105b9: b0 01 mov $0x1,%al <== NOT EXECUTED return true; } 1105bb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1105be: 5b pop %ebx <== NOT EXECUTED 1105bf: 5e pop %esi <== NOT EXECUTED 1105c0: 5f pop %edi <== NOT EXECUTED 1105c1: c9 leave <== NOT EXECUTED 1105c2: c3 ret <== NOT EXECUTED 1105c3: 90 nop <== NOT EXECUTED /* * Restore the previous set of blocked signals */ api->signals_blocked = saved_signals_blocked; return true; 1105c4: 31 c0 xor %eax,%eax <== NOT EXECUTED } 1105c6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1105c9: 5b pop %ebx <== NOT EXECUTED 1105ca: 5e pop %esi <== NOT EXECUTED 1105cb: 5f pop %edi <== NOT EXECUTED 1105cc: c9 leave <== NOT EXECUTED 1105cd: c3 ret <== NOT EXECUTED 1105ce: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Here, the signal handler function executes */ switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) { case SA_SIGINFO: (*_POSIX_signals_Vectors[ signo ].sa_sigaction)( 1105d0: 50 push %eax <== NOT EXECUTED 1105d1: 6a 00 push $0x0 <== NOT EXECUTED 1105d3: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 1105d6: 50 push %eax <== NOT EXECUTED 1105d7: 53 push %ebx <== NOT EXECUTED 1105d8: ff 92 08 fe 11 00 call *0x11fe08(%edx) <== NOT EXECUTED 1105de: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1105e1: eb d0 jmp 1105b3 <_POSIX_signals_Check_signal+0x63> <== NOT EXECUTED 00110c44 <_POSIX_signals_Clear_process_signals>: */ void _POSIX_signals_Clear_process_signals( sigset_t mask ) { 110c44: 55 push %ebp <== NOT EXECUTED 110c45: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110c47: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 110c4a: 9c pushf <== NOT EXECUTED 110c4b: fa cli <== NOT EXECUTED 110c4c: 5a pop %edx <== NOT EXECUTED _POSIX_signals_Pending &= ~mask; 110c4d: f7 d0 not %eax <== NOT EXECUTED 110c4f: 23 05 e0 ff 11 00 and 0x11ffe0,%eax <== NOT EXECUTED 110c55: a3 e0 ff 11 00 mov %eax,0x11ffe0 <== NOT EXECUTED if ( !_POSIX_signals_Pending ) 110c5a: 85 c0 test %eax,%eax <== NOT EXECUTED 110c5c: 75 06 jne 110c64 <_POSIX_signals_Clear_process_signals+0x20> <== NOT EXECUTED _Thread_Do_post_task_switch_extension--; 110c5e: ff 0d 60 f8 11 00 decl 0x11f860 <== NOT EXECUTED _ISR_Enable( level ); 110c64: 52 push %edx <== NOT EXECUTED 110c65: 9d popf <== NOT EXECUTED } 110c66: c9 leave <== NOT EXECUTED 110c67: c3 ret <== NOT EXECUTED 001105e4 <_POSIX_signals_Clear_signals>: int signo, siginfo_t *info, bool is_global, bool check_blocked ) { 1105e4: 55 push %ebp <== NOT EXECUTED 1105e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1105e7: 57 push %edi <== NOT EXECUTED 1105e8: 56 push %esi <== NOT EXECUTED 1105e9: 53 push %ebx <== NOT EXECUTED 1105ea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1105ed: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1105f0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1105f3: 8a 45 14 mov 0x14(%ebp),%al <== NOT EXECUTED sigset_t signals_blocked; ISR_Level level; bool do_callout; POSIX_signals_Siginfo_node *psiginfo; mask = signo_to_mask( signo ); 1105f6: 8d 4e ff lea -0x1(%esi),%ecx <== NOT EXECUTED 1105f9: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 1105fe: d3 e3 shl %cl,%ebx <== NOT EXECUTED /* 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 ) 110600: 80 7d 18 00 cmpb $0x0,0x18(%ebp) <== NOT EXECUTED 110604: 0f 85 9e 00 00 00 jne 1106a8 <_POSIX_signals_Clear_signals+0xc4> <== NOT EXECUTED 11060a: ba ff ff ff ff mov $0xffffffff,%edx <== NOT EXECUTED 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 ); 11060f: 9c pushf <== NOT EXECUTED 110610: fa cli <== NOT EXECUTED 110611: 8f 45 f0 popl -0x10(%ebp) <== NOT EXECUTED if ( is_global ) { 110614: 84 c0 test %al,%al <== NOT EXECUTED 110616: 0f 84 9c 00 00 00 je 1106b8 <_POSIX_signals_Clear_signals+0xd4> <== NOT EXECUTED if ( mask & (_POSIX_signals_Pending & signals_blocked) ) { 11061c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11061e: 23 05 e0 ff 11 00 and 0x11ffe0,%eax <== NOT EXECUTED 110624: 85 d0 test %edx,%eax <== NOT EXECUTED 110626: 0f 84 b4 00 00 00 je 1106e0 <_POSIX_signals_Clear_signals+0xfc> <== NOT EXECUTED if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) { 11062c: 8d 04 76 lea (%esi,%esi,2),%eax <== NOT EXECUTED 11062f: 8d 14 85 00 00 00 00 lea 0x0(,%eax,4),%edx <== NOT EXECUTED 110636: 83 ba 00 fe 11 00 02 cmpl $0x2,0x11fe00(%edx) <== NOT EXECUTED 11063d: 0f 85 a1 00 00 00 jne 1106e4 <_POSIX_signals_Clear_signals+0x100> <== NOT EXECUTED psiginfo = (POSIX_signals_Siginfo_node *) 110643: 8d ba 00 00 12 00 lea 0x120000(%edx),%edi <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 110649: 8b 8a 00 00 12 00 mov 0x120000(%edx),%ecx <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 11064f: 8d 77 04 lea 0x4(%edi),%esi <== NOT EXECUTED 110652: 39 f1 cmp %esi,%ecx <== NOT EXECUTED 110654: 0f 84 9a 00 00 00 je 1106f4 <_POSIX_signals_Clear_signals+0x110> <== NOT EXECUTED 11065a: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 11065c: 89 82 00 00 12 00 mov %eax,0x120000(%edx) <== NOT EXECUTED 110662: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED 110665: 89 4d e8 mov %ecx,-0x18(%ebp) <== NOT EXECUTED _Chain_Get_unprotected( &_POSIX_signals_Siginfo[ signo ] ); if ( _Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) ) 110668: 39 c6 cmp %eax,%esi <== NOT EXECUTED 11066a: 0f 84 8b 00 00 00 je 1106fb <_POSIX_signals_Clear_signals+0x117> <== NOT EXECUTED _POSIX_signals_Clear_process_signals( mask ); if ( psiginfo ) { 110670: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 110673: 85 c0 test %eax,%eax <== NOT EXECUTED 110675: 74 2c je 1106a3 <_POSIX_signals_Clear_signals+0xbf> <== NOT EXECUTED *info = psiginfo->Info; 110677: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 11067a: 83 c6 08 add $0x8,%esi <== NOT EXECUTED 11067d: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 110682: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 110685: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 110687: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11068a: c7 00 84 ff 11 00 movl $0x11ff84,(%eax) <== NOT EXECUTED 110690: a1 88 ff 11 00 mov 0x11ff88,%eax <== NOT EXECUTED 110695: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 110698: 89 15 88 ff 11 00 mov %edx,0x11ff88 <== NOT EXECUTED 11069e: 89 10 mov %edx,(%eax) <== NOT EXECUTED 1106a0: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 1106a3: b0 01 mov $0x1,%al <== NOT EXECUTED 1106a5: eb 2d jmp 1106d4 <_POSIX_signals_Clear_signals+0xf0> <== NOT EXECUTED 1106a7: 90 nop <== NOT EXECUTED /* 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 ) signals_blocked = ~api->signals_blocked; 1106a8: 8b 97 c4 00 00 00 mov 0xc4(%edi),%edx <== NOT EXECUTED 1106ae: f7 d2 not %edx <== NOT EXECUTED 1106b0: e9 5a ff ff ff jmp 11060f <_POSIX_signals_Clear_signals+0x2b> <== NOT EXECUTED 1106b5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } else _POSIX_signals_Clear_process_signals( mask ); do_callout = true; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { 1106b8: 8b 8f c8 00 00 00 mov 0xc8(%edi),%ecx <== NOT EXECUTED 1106be: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1106c0: 21 c8 and %ecx,%eax <== NOT EXECUTED 1106c2: 85 d0 test %edx,%eax <== NOT EXECUTED 1106c4: 74 1a je 1106e0 <_POSIX_signals_Clear_signals+0xfc> <== NOT EXECUTED api->signals_pending &= ~mask; 1106c6: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1106c8: f7 d0 not %eax <== NOT EXECUTED 1106ca: 21 c8 and %ecx,%eax <== NOT EXECUTED 1106cc: 89 87 c8 00 00 00 mov %eax,0xc8(%edi) <== NOT EXECUTED 1106d2: b0 01 mov $0x1,%al <== NOT EXECUTED do_callout = true; } } _ISR_Enable( level ); 1106d4: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 1106d7: 9d popf <== NOT EXECUTED return do_callout; } 1106d8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1106db: 5b pop %ebx <== NOT EXECUTED 1106dc: 5e pop %esi <== NOT EXECUTED 1106dd: 5f pop %edi <== NOT EXECUTED 1106de: c9 leave <== NOT EXECUTED 1106df: c3 ret <== NOT EXECUTED _POSIX_signals_Clear_process_signals( mask ); do_callout = true; } } else { if ( mask & (api->signals_pending & signals_blocked) ) { api->signals_pending &= ~mask; 1106e0: 31 c0 xor %eax,%eax <== NOT EXECUTED 1106e2: eb f0 jmp 1106d4 <_POSIX_signals_Clear_signals+0xf0> <== NOT EXECUTED &psiginfo->Node ); } else do_callout = false; } else _POSIX_signals_Clear_process_signals( mask ); 1106e4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1106e7: 53 push %ebx <== NOT EXECUTED 1106e8: e8 57 05 00 00 call 110c44 <_POSIX_signals_Clear_process_signals> <== NOT EXECUTED 1106ed: b0 01 mov $0x1,%al <== NOT EXECUTED 1106ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1106f2: eb e0 jmp 1106d4 <_POSIX_signals_Clear_signals+0xf0> <== NOT EXECUTED 1106f4: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp) <== NOT EXECUTED 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 ] ) ) _POSIX_signals_Clear_process_signals( mask ); 1106fb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1106fe: 53 push %ebx <== NOT EXECUTED 1106ff: e8 40 05 00 00 call 110c44 <_POSIX_signals_Clear_process_signals> <== NOT EXECUTED 110704: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110707: e9 64 ff ff ff jmp 110670 <_POSIX_signals_Clear_signals+0x8c> <== NOT EXECUTED 0010ad7c <_POSIX_signals_Get_highest>: #include int _POSIX_signals_Get_highest( sigset_t set ) { 10ad7c: 55 push %ebp <== NOT EXECUTED 10ad7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad7f: 56 push %esi <== NOT EXECUTED 10ad80: 53 push %ebx <== NOT EXECUTED 10ad81: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10ad84: b8 1b 00 00 00 mov $0x1b,%eax <== NOT EXECUTED int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( set & signo_to_mask( signo ) ) 10ad89: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10ad8e: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 10ad91: 89 d6 mov %edx,%esi <== NOT EXECUTED 10ad93: d3 e6 shl %cl,%esi <== NOT EXECUTED 10ad95: 85 de test %ebx,%esi <== NOT EXECUTED 10ad97: 75 20 jne 10adb9 <_POSIX_signals_Get_highest+0x3d> <== NOT EXECUTED sigset_t set ) { int signo; for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10ad99: 40 inc %eax <== NOT EXECUTED 10ad9a: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED 10ad9d: 75 ef jne 10ad8e <_POSIX_signals_Get_highest+0x12> <== NOT EXECUTED 10ad9f: b0 01 mov $0x1,%al <== NOT EXECUTED } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { if ( set & signo_to_mask( signo ) ) 10ada1: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10ada6: eb 06 jmp 10adae <_POSIX_signals_Get_highest+0x32> <== NOT EXECUTED return signo; } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10ada8: 40 inc %eax <== NOT EXECUTED 10ada9: 83 f8 1b cmp $0x1b,%eax <== NOT EXECUTED 10adac: 74 12 je 10adc0 <_POSIX_signals_Get_highest+0x44> <== NOT EXECUTED if ( set & signo_to_mask( signo ) ) 10adae: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 10adb1: 89 d6 mov %edx,%esi <== NOT EXECUTED 10adb3: d3 e6 shl %cl,%esi <== NOT EXECUTED 10adb5: 85 de test %ebx,%esi <== NOT EXECUTED 10adb7: 74 ef je 10ada8 <_POSIX_signals_Get_highest+0x2c> <== NOT EXECUTED return signo; } return 0; } 10adb9: 5b pop %ebx <== NOT EXECUTED 10adba: 5e pop %esi <== NOT EXECUTED 10adbb: c9 leave <== NOT EXECUTED 10adbc: c3 ret <== NOT EXECUTED 10adbd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return signo; } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10adc0: 30 c0 xor %al,%al <== NOT EXECUTED if ( set & signo_to_mask( signo ) ) return signo; } return 0; } 10adc2: 5b pop %ebx <== NOT EXECUTED 10adc3: 5e pop %esi <== NOT EXECUTED 10adc4: c9 leave <== NOT EXECUTED 10adc5: c3 ret <== NOT EXECUTED 0010ed84 <_POSIX_signals_Manager_Initialization>: */ void _POSIX_signals_Manager_Initialization( int maximum_queued_signals ) { 10ed84: 55 push %ebp <== NOT EXECUTED 10ed85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ed87: 57 push %edi <== NOT EXECUTED 10ed88: 56 push %esi <== NOT EXECUTED 10ed89: 53 push %ebx <== NOT EXECUTED 10ed8a: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10ed8d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED assert( sizeof(_POSIX_signals_Vectors) == sizeof(_POSIX_signals_Default_vectors) ); memcpy( 10ed90: bf 00 fe 11 00 mov $0x11fe00,%edi <== NOT EXECUTED 10ed95: be a0 95 11 00 mov $0x1195a0,%esi <== NOT EXECUTED 10ed9a: b9 60 00 00 00 mov $0x60,%ecx <== NOT EXECUTED 10ed9f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* * Initialize the set of pending signals for the entire process */ sigemptyset( &_POSIX_signals_Pending ); 10eda1: 68 e0 ff 11 00 push $0x11ffe0 <== NOT EXECUTED 10eda6: e8 b9 04 00 00 call 10f264 <== NOT EXECUTED /* * Initialize the queue we use to block for signals */ _Thread_queue_Initialize( 10edab: 6a 0b push $0xb <== NOT EXECUTED 10edad: 68 00 80 00 10 push $0x10008000 <== NOT EXECUTED 10edb2: 6a 01 push $0x1 <== NOT EXECUTED 10edb4: 68 a0 ff 11 00 push $0x11ffa0 <== NOT EXECUTED 10edb9: e8 c2 dc ff ff call 10ca80 <_Thread_queue_Initialize> <== NOT EXECUTED 10edbe: ba 0c 00 12 00 mov $0x12000c,%edx <== NOT EXECUTED 10edc3: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10edc6: 66 90 xchg %ax,%ax <== NOT EXECUTED 10edc8: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10edcb: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10edcd: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10edd4: 89 52 08 mov %edx,0x8(%edx) <== NOT EXECUTED 10edd7: 83 c2 0c add $0xc,%edx <== NOT EXECUTED /* * Allocate the siginfo pools. */ for ( signo=1 ; signo<= SIGRTMAX ; signo++ ) 10edda: 81 fa 80 01 12 00 cmp $0x120180,%edx <== NOT EXECUTED 10ede0: 75 e6 jne 10edc8 <_POSIX_signals_Manager_Initialization+0x44> <== NOT EXECUTED _Chain_Initialize_empty( &_POSIX_signals_Siginfo[ signo ] ); if ( maximum_queued_signals ) { 10ede2: 85 db test %ebx,%ebx <== NOT EXECUTED 10ede4: 75 26 jne 10ee0c <_POSIX_signals_Manager_Initialization+0x88> <== NOT EXECUTED 10ede6: c7 05 80 ff 11 00 84 movl $0x11ff84,0x11ff80 <== NOT EXECUTED 10eded: ff 11 00 <== NOT EXECUTED 10edf0: c7 05 84 ff 11 00 00 movl $0x0,0x11ff84 <== NOT EXECUTED 10edf7: 00 00 00 <== NOT EXECUTED 10edfa: c7 05 88 ff 11 00 80 movl $0x11ff80,0x11ff88 <== NOT EXECUTED 10ee01: ff 11 00 <== NOT EXECUTED sizeof( POSIX_signals_Siginfo_node ) ); } else { _Chain_Initialize_empty( &_POSIX_signals_Inactive_siginfo ); } } 10ee04: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ee07: 5b pop %ebx <== NOT EXECUTED 10ee08: 5e pop %esi <== NOT EXECUTED 10ee09: 5f pop %edi <== NOT EXECUTED 10ee0a: c9 leave <== NOT EXECUTED 10ee0b: c3 ret <== NOT EXECUTED for ( signo=1 ; signo<= SIGRTMAX ; signo++ ) _Chain_Initialize_empty( &_POSIX_signals_Siginfo[ signo ] ); if ( maximum_queued_signals ) { _Chain_Initialize( 10ee0c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ee0f: 8d 04 9b lea (%ebx,%ebx,4),%eax <== NOT EXECUTED 10ee12: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10ee15: 50 push %eax <== NOT EXECUTED 10ee16: e8 7d e6 ff ff call 10d498 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10ee1b: 6a 14 push $0x14 <== NOT EXECUTED 10ee1d: 53 push %ebx <== NOT EXECUTED 10ee1e: 50 push %eax <== NOT EXECUTED 10ee1f: 68 80 ff 11 00 push $0x11ff80 <== NOT EXECUTED 10ee24: e8 a7 08 00 00 call 10f6d0 <_Chain_Initialize> <== NOT EXECUTED 10ee29: 83 c4 20 add $0x20,%esp <== NOT EXECUTED sizeof( POSIX_signals_Siginfo_node ) ); } else { _Chain_Initialize_empty( &_POSIX_signals_Inactive_siginfo ); } } 10ee2c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ee2f: 5b pop %ebx <== NOT EXECUTED 10ee30: 5e pop %esi <== NOT EXECUTED 10ee31: 5f pop %edi <== NOT EXECUTED 10ee32: c9 leave <== NOT EXECUTED 10ee33: c3 ret <== NOT EXECUTED 0010ee34 <_POSIX_signals_Post_switch_extension>: */ void _POSIX_signals_Post_switch_extension( Thread_Control *the_thread ) { 10ee34: 55 push %ebp <== NOT EXECUTED 10ee35: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ee37: 56 push %esi <== NOT EXECUTED 10ee38: 53 push %ebx <== NOT EXECUTED POSIX_API_Control *api; int signo; ISR_Level level; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10ee39: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ee3c: 8b b0 f8 00 00 00 mov 0xf8(%eax),%esi <== NOT EXECUTED if ( !api ) 10ee42: 85 f6 test %esi,%esi <== NOT EXECUTED 10ee44: 74 7c je 10eec2 <_POSIX_signals_Post_switch_extension+0x8e> <== NOT EXECUTED 10ee46: 66 90 xchg %ax,%ax <== NOT EXECUTED * The first thing done is to check there are any signals to be * processed at all. No point in doing this loop otherwise. */ while (1) { restart: _ISR_Disable( level ); 10ee48: 9c pushf <== NOT EXECUTED 10ee49: fa cli <== NOT EXECUTED 10ee4a: 59 pop %ecx <== NOT EXECUTED if ( !(~api->signals_blocked & 10ee4b: 8b 15 e0 ff 11 00 mov 0x11ffe0,%edx <== NOT EXECUTED 10ee51: 0b 96 c8 00 00 00 or 0xc8(%esi),%edx <== NOT EXECUTED 10ee57: 8b 86 c4 00 00 00 mov 0xc4(%esi),%eax <== NOT EXECUTED 10ee5d: f7 d0 not %eax <== NOT EXECUTED 10ee5f: 85 c2 test %eax,%edx <== NOT EXECUTED 10ee61: 74 5d je 10eec0 <_POSIX_signals_Post_switch_extension+0x8c> <== NOT EXECUTED (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); break; } _ISR_Enable( level ); 10ee63: 51 push %ecx <== NOT EXECUTED 10ee64: 9d popf <== NOT EXECUTED 10ee65: bb 1b 00 00 00 mov $0x1b,%ebx <== NOT EXECUTED for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { if ( _POSIX_signals_Check_signal( api, signo, false ) ) 10ee6a: 50 push %eax <== NOT EXECUTED 10ee6b: 6a 00 push $0x0 <== NOT EXECUTED 10ee6d: 53 push %ebx <== NOT EXECUTED 10ee6e: 56 push %esi <== NOT EXECUTED 10ee6f: e8 dc 16 00 00 call 110550 <_POSIX_signals_Check_signal> <== NOT EXECUTED 10ee74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ee77: 84 c0 test %al,%al <== NOT EXECUTED 10ee79: 75 cd jne 10ee48 <_POSIX_signals_Post_switch_extension+0x14> <== NOT EXECUTED goto restart; if ( _POSIX_signals_Check_signal( api, signo, true ) ) 10ee7b: 51 push %ecx <== NOT EXECUTED 10ee7c: 6a 01 push $0x1 <== NOT EXECUTED 10ee7e: 53 push %ebx <== NOT EXECUTED 10ee7f: 56 push %esi <== NOT EXECUTED 10ee80: e8 cb 16 00 00 call 110550 <_POSIX_signals_Check_signal> <== NOT EXECUTED 10ee85: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ee88: 84 c0 test %al,%al <== NOT EXECUTED 10ee8a: 75 bc jne 10ee48 <_POSIX_signals_Post_switch_extension+0x14> <== NOT EXECUTED _ISR_Enable( level ); break; } _ISR_Enable( level ); for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { 10ee8c: 43 inc %ebx <== NOT EXECUTED 10ee8d: 83 fb 20 cmp $0x20,%ebx <== NOT EXECUTED 10ee90: 75 d8 jne 10ee6a <_POSIX_signals_Post_switch_extension+0x36> <== NOT EXECUTED 10ee92: b3 01 mov $0x1,%bl <== NOT EXECUTED /* 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 ) ) 10ee94: 52 push %edx <== NOT EXECUTED 10ee95: 6a 00 push $0x0 <== NOT EXECUTED 10ee97: 53 push %ebx <== NOT EXECUTED 10ee98: 56 push %esi <== NOT EXECUTED 10ee99: e8 b2 16 00 00 call 110550 <_POSIX_signals_Check_signal> <== NOT EXECUTED 10ee9e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eea1: 84 c0 test %al,%al <== NOT EXECUTED 10eea3: 75 a3 jne 10ee48 <_POSIX_signals_Post_switch_extension+0x14> <== NOT EXECUTED goto restart; if ( _POSIX_signals_Check_signal( api, signo, true ) ) 10eea5: 50 push %eax <== NOT EXECUTED 10eea6: 6a 01 push $0x1 <== NOT EXECUTED 10eea8: 53 push %ebx <== NOT EXECUTED 10eea9: 56 push %esi <== NOT EXECUTED 10eeaa: e8 a1 16 00 00 call 110550 <_POSIX_signals_Check_signal> <== NOT EXECUTED 10eeaf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eeb2: 84 c0 test %al,%al <== NOT EXECUTED 10eeb4: 75 92 jne 10ee48 <_POSIX_signals_Post_switch_extension+0x14> <== NOT EXECUTED } /* XXX - add __SIGFIRSTNOTRT or something like that to newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { 10eeb6: 43 inc %ebx <== NOT EXECUTED 10eeb7: 83 fb 1b cmp $0x1b,%ebx <== NOT EXECUTED 10eeba: 75 d8 jne 10ee94 <_POSIX_signals_Post_switch_extension+0x60> <== NOT EXECUTED 10eebc: eb 8a jmp 10ee48 <_POSIX_signals_Post_switch_extension+0x14> <== NOT EXECUTED 10eebe: 66 90 xchg %ax,%ax <== NOT EXECUTED while (1) { restart: _ISR_Disable( level ); if ( !(~api->signals_blocked & (api->signals_pending | _POSIX_signals_Pending)) ) { _ISR_Enable( level ); 10eec0: 51 push %ecx <== NOT EXECUTED 10eec1: 9d popf <== NOT EXECUTED goto restart; } } return; } 10eec2: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10eec5: 5b pop %ebx <== NOT EXECUTED 10eec6: 5e pop %esi <== NOT EXECUTED 10eec7: c9 leave <== NOT EXECUTED 10eec8: c3 ret <== NOT EXECUTED 00121e48 <_POSIX_signals_Set_process_signals>: */ void _POSIX_signals_Set_process_signals( sigset_t mask ) { 121e48: 55 push %ebp <== NOT EXECUTED 121e49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121e4b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 121e4e: 9c pushf <== NOT EXECUTED 121e4f: fa cli <== NOT EXECUTED 121e50: 59 pop %ecx <== NOT EXECUTED if ( !_POSIX_signals_Pending ) 121e51: 8b 15 60 e5 12 00 mov 0x12e560,%edx <== NOT EXECUTED 121e57: 85 d2 test %edx,%edx <== NOT EXECUTED 121e59: 75 06 jne 121e61 <_POSIX_signals_Set_process_signals+0x19> <== NOT EXECUTED _Thread_Do_post_task_switch_extension++; 121e5b: ff 05 60 dd 12 00 incl 0x12dd60 <== NOT EXECUTED _POSIX_signals_Pending |= mask; 121e61: 09 d0 or %edx,%eax <== NOT EXECUTED 121e63: a3 60 e5 12 00 mov %eax,0x12e560 <== NOT EXECUTED _ISR_Enable( level ); 121e68: 51 push %ecx <== NOT EXECUTED 121e69: 9d popf <== NOT EXECUTED } 121e6a: c9 leave <== NOT EXECUTED 121e6b: c3 ret <== NOT EXECUTED 0010a084 <_POSIX_signals_Ualarm_TSR>: void _POSIX_signals_Ualarm_TSR( Objects_Id id, void *argument ) { 10a084: 55 push %ebp <== NOT EXECUTED 10a085: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a087: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED /* * Send a SIGALRM but if there is a problem, ignore it. * It's OK, there isn't a way this should fail. */ (void) kill( getpid(), SIGALRM ); 10a08a: e8 9d d2 ff ff call 10732c <== NOT EXECUTED 10a08f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a092: 6a 0e push $0xe <== NOT EXECUTED 10a094: 50 push %eax <== NOT EXECUTED 10a095: e8 ca fc ff ff call 109d64 <== NOT EXECUTED Heap_Control *the_heap, Heap_Information_block *the_info ); /** * This heap routine returns information about the free blocks 10a09a: c7 04 24 a0 21 12 00 movl $0x1221a0,(%esp) <== NOT EXECUTED 10a0a1: e8 ae 39 00 00 call 10da54 <_Watchdog_Remove> <== NOT EXECUTED * in the specified heap. * 10a0a6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0a9: c7 45 0c a0 21 12 00 movl $0x1221a0,0xc(%ebp) <== NOT EXECUTED 10a0b0: c7 45 08 7c 23 12 00 movl $0x12237c,0x8(%ebp) <== NOT EXECUTED /* * If the reset interval is non-zero, reschedule ourselves. */ _Watchdog_Reset( &_POSIX_signals_Ualarm_timer ); } 10a0b7: c9 leave <== NOT EXECUTED 10a0b8: e9 67 38 00 00 jmp 10d924 <_Watchdog_Insert> <== NOT EXECUTED 00121e6c <_POSIX_signals_Unblock_thread>: bool _POSIX_signals_Unblock_thread( Thread_Control *the_thread, int signo, siginfo_t *info ) { 121e6c: 55 push %ebp <== NOT EXECUTED 121e6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121e6f: 57 push %edi <== NOT EXECUTED 121e70: 56 push %esi <== NOT EXECUTED 121e71: 53 push %ebx <== NOT EXECUTED 121e72: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 121e75: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 121e78: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED POSIX_API_Control *api; sigset_t mask; siginfo_t *the_info = NULL; api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 121e7b: 8b bb f8 00 00 00 mov 0xf8(%ebx),%edi <== NOT EXECUTED mask = signo_to_mask( signo ); 121e81: 8d 4e ff lea -0x1(%esi),%ecx <== NOT EXECUTED 121e84: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 121e89: d3 e2 shl %cl,%edx <== NOT EXECUTED /* * Is the thread is specifically waiting for a signal? */ if ( _States_Is_interruptible_signal( the_thread->current_state ) ) { 121e8b: 8b 4b 10 mov 0x10(%ebx),%ecx <== NOT EXECUTED 121e8e: 89 c8 mov %ecx,%eax <== NOT EXECUTED 121e90: 25 00 80 00 10 and $0x10008000,%eax <== NOT EXECUTED 121e95: 3d 00 80 00 10 cmp $0x10008000,%eax <== NOT EXECUTED 121e9a: 74 70 je 121f0c <_POSIX_signals_Unblock_thread+0xa0> <== NOT EXECUTED } /* * Thread is not waiting due to a sigwait. */ if ( ~api->signals_blocked & mask ) { 121e9c: 8b 87 c4 00 00 00 mov 0xc4(%edi),%eax <== NOT EXECUTED 121ea2: f7 d0 not %eax <== NOT EXECUTED 121ea4: 85 c2 test %eax,%edx <== NOT EXECUTED 121ea6: 74 58 je 121f00 <_POSIX_signals_Unblock_thread+0x94> <== NOT EXECUTED * it is not blocked, THEN * we need to dispatch at the end of this ISR. * + Any other combination, do nothing. */ the_thread->do_post_task_switch_extension = true; 121ea8: c6 43 75 01 movb $0x1,0x75(%ebx) <== NOT EXECUTED if ( the_thread->current_state & STATES_INTERRUPTIBLE_BY_SIGNAL ) { 121eac: f7 c1 00 00 00 10 test $0x10000000,%ecx <== NOT EXECUTED 121eb2: 74 34 je 121ee8 <_POSIX_signals_Unblock_thread+0x7c> <== NOT EXECUTED the_thread->Wait.return_code = EINTR; 121eb4: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) <== NOT EXECUTED #if 0 if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) ) _Thread_queue_Extract_with_proxy( the_thread ); else #endif if ( _States_Is_delaying(the_thread->current_state) ){ 121ebb: 83 e1 08 and $0x8,%ecx <== NOT EXECUTED 121ebe: 74 40 je 121f00 <_POSIX_signals_Unblock_thread+0x94> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 121ec0: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 121ec4: 0f 84 aa 00 00 00 je 121f74 <_POSIX_signals_Unblock_thread+0x108> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 121eca: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 121ecd: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 121ed2: 53 push %ebx <== NOT EXECUTED 121ed3: e8 d8 ee fe ff call 110db0 <_Thread_Clear_state> <== NOT EXECUTED 121ed8: 31 c0 xor %eax,%eax <== NOT EXECUTED 121eda: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _ISR_Signals_to_thread_executing = TRUE; } } return false; } 121edd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 121ee0: 5b pop %ebx <== NOT EXECUTED 121ee1: 5e pop %esi <== NOT EXECUTED 121ee2: 5f pop %edi <== NOT EXECUTED 121ee3: c9 leave <== NOT EXECUTED 121ee4: c3 ret <== NOT EXECUTED 121ee5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( _States_Is_delaying(the_thread->current_state) ){ if ( _Watchdog_Is_active( &the_thread->Timer ) ) (void) _Watchdog_Remove( &the_thread->Timer ); _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { 121ee8: 85 c9 test %ecx,%ecx <== NOT EXECUTED 121eea: 75 14 jne 121f00 <_POSIX_signals_Unblock_thread+0x94> <== NOT EXECUTED if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 121eec: a1 58 dd 12 00 mov 0x12dd58,%eax <== NOT EXECUTED 121ef1: 85 c0 test %eax,%eax <== NOT EXECUTED 121ef3: 74 0b je 121f00 <_POSIX_signals_Unblock_thread+0x94> <== NOT EXECUTED 121ef5: 3b 1d 7c dd 12 00 cmp 0x12dd7c,%ebx <== NOT EXECUTED 121efb: 74 55 je 121f52 <_POSIX_signals_Unblock_thread+0xe6> <== NOT EXECUTED 121efd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 121f00: 31 c0 xor %eax,%eax <== NOT EXECUTED } } return false; } 121f02: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 121f05: 5b pop %ebx <== NOT EXECUTED 121f06: 5e pop %esi <== NOT EXECUTED 121f07: 5f pop %edi <== NOT EXECUTED 121f08: c9 leave <== NOT EXECUTED 121f09: c3 ret <== NOT EXECUTED 121f0a: 66 90 xchg %ax,%ax <== NOT EXECUTED * 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) ) { 121f0c: 85 53 30 test %edx,0x30(%ebx) <== NOT EXECUTED 121f0f: 74 33 je 121f44 <_POSIX_signals_Unblock_thread+0xd8> <== NOT EXECUTED the_thread->Wait.return_code = EINTR; 121f11: c7 43 34 04 00 00 00 movl $0x4,0x34(%ebx) <== NOT EXECUTED the_info = (siginfo_t *) the_thread->Wait.return_argument; 121f18: 8b 7b 28 mov 0x28(%ebx),%edi <== NOT EXECUTED if ( !info ) { 121f1b: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 121f1e: 85 c0 test %eax,%eax <== NOT EXECUTED 121f20: 74 3e je 121f60 <_POSIX_signals_Unblock_thread+0xf4> <== NOT EXECUTED the_info->si_signo = signo; the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; } else { *the_info = *info; 121f22: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 121f27: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 121f2a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED } _Thread_queue_Extract_with_proxy( the_thread ); 121f2c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 121f2f: 53 push %ebx <== NOT EXECUTED 121f30: e8 2b f9 fe ff call 111860 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 121f35: b0 01 mov $0x1,%al <== NOT EXECUTED 121f37: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _ISR_Signals_to_thread_executing = TRUE; } } return false; } 121f3a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 121f3d: 5b pop %ebx <== NOT EXECUTED 121f3e: 5e pop %esi <== NOT EXECUTED 121f3f: 5f pop %edi <== NOT EXECUTED 121f40: c9 leave <== NOT EXECUTED 121f41: c3 ret <== NOT EXECUTED 121f42: 66 90 xchg %ax,%ax <== NOT EXECUTED * 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) ) { 121f44: 8b 87 c4 00 00 00 mov 0xc4(%edi),%eax <== NOT EXECUTED 121f4a: f7 d0 not %eax <== NOT EXECUTED 121f4c: 85 c2 test %eax,%edx <== NOT EXECUTED 121f4e: 75 c1 jne 121f11 <_POSIX_signals_Unblock_thread+0xa5> <== NOT EXECUTED 121f50: eb ae jmp 121f00 <_POSIX_signals_Unblock_thread+0x94> <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); _Thread_Unblock( the_thread ); } } else if ( the_thread->current_state == STATES_READY ) { if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _ISR_Signals_to_thread_executing = TRUE; 121f52: c6 05 28 de 12 00 01 movb $0x1,0x12de28 <== NOT EXECUTED 121f59: 31 c0 xor %eax,%eax <== NOT EXECUTED 121f5b: eb a5 jmp 121f02 <_POSIX_signals_Unblock_thread+0x96> <== NOT EXECUTED 121f5d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_thread->Wait.return_code = EINTR; the_info = (siginfo_t *) the_thread->Wait.return_argument; if ( !info ) { the_info->si_signo = signo; 121f60: 89 37 mov %esi,(%edi) <== NOT EXECUTED the_info->si_code = SI_USER; 121f62: c7 47 04 01 00 00 00 movl $0x1,0x4(%edi) <== NOT EXECUTED the_info->si_value.sival_int = 0; 121f69: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi) <== NOT EXECUTED 121f70: eb ba jmp 121f2c <_POSIX_signals_Unblock_thread+0xc0> <== NOT EXECUTED 121f72: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_queue_Extract_with_proxy( the_thread ); else #endif if ( _States_Is_delaying(the_thread->current_state) ){ if ( _Watchdog_Is_active( &the_thread->Timer ) ) (void) _Watchdog_Remove( &the_thread->Timer ); 121f74: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 121f77: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 121f7a: 50 push %eax <== NOT EXECUTED 121f7b: e8 d4 02 ff ff call 112254 <_Watchdog_Remove> <== NOT EXECUTED 121f80: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121f83: e9 42 ff ff ff jmp 121eca <_POSIX_signals_Unblock_thread+0x5e> <== NOT EXECUTED 0010f318 <_Partition_Manager_initialization>: */ void _Partition_Manager_initialization( uint32_t maximum_partitions ) { 10f318: 55 push %ebp <== NOT EXECUTED 10f319: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f31b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f31e: 6a 04 push $0x4 <== NOT EXECUTED 10f320: 6a 00 push $0x0 <== NOT EXECUTED 10f322: 6a 30 push $0x30 <== NOT EXECUTED 10f324: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f327: 6a 05 push $0x5 <== NOT EXECUTED 10f329: 6a 02 push $0x2 <== NOT EXECUTED 10f32b: 68 c0 02 12 00 push $0x1202c0 <== NOT EXECUTED 10f330: e8 37 c8 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f335: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_PARTITION, _Partition_MP_Process_packet ); #endif } 10f338: c9 leave <== NOT EXECUTED 10f339: c3 ret <== NOT EXECUTED 0010bdbc <_Protected_heap_Allocate>: void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ) { 10bdbc: 55 push %ebp <== NOT EXECUTED 10bdbd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bdbf: 53 push %ebx <== NOT EXECUTED 10bdc0: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *p; _RTEMS_Lock_allocator(); 10bdc3: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10bdc9: e8 9a ef ff ff call 10ad68 <_API_Mutex_Lock> <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 10bdce: 5a pop %edx <== NOT EXECUTED 10bdcf: 59 pop %ecx <== NOT EXECUTED 10bdd0: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10bdd3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bdd6: e8 61 3b 00 00 call 10f93c <_Heap_Allocate> <== NOT EXECUTED 10bddb: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10bddd: 58 pop %eax <== NOT EXECUTED 10bdde: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10bde4: e8 c7 ef ff ff call 10adb0 <_API_Mutex_Unlock> <== NOT EXECUTED return p; } 10bde9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bdeb: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bdee: c9 leave <== NOT EXECUTED 10bdef: c3 ret <== NOT EXECUTED 0010dc54 <_Protected_heap_Allocate_aligned>: void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 10dc54: 55 push %ebp <== NOT EXECUTED 10dc55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc57: 53 push %ebx <== NOT EXECUTED 10dc58: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *p; _RTEMS_Lock_allocator(); 10dc5b: ff 35 14 4f 12 00 pushl 0x124f14 <== NOT EXECUTED 10dc61: e8 be e9 ff ff call 10c624 <_API_Mutex_Lock> <== NOT EXECUTED p = _Heap_Allocate_aligned( the_heap, size, alignment ); 10dc66: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10dc69: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dc6c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dc6f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10dc72: e8 49 f0 ff ff call 10ccc0 <_Heap_Allocate_aligned> <== NOT EXECUTED 10dc77: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10dc79: 58 pop %eax <== NOT EXECUTED 10dc7a: ff 35 14 4f 12 00 pushl 0x124f14 <== NOT EXECUTED 10dc80: e8 e7 e9 ff ff call 10c66c <_API_Mutex_Unlock> <== NOT EXECUTED return p; } 10dc85: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10dc87: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10dc8a: c9 leave <== NOT EXECUTED 10dc8b: c3 ret <== NOT EXECUTED 0010dcc0 <_Protected_heap_Extend>: bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ) { 10dcc0: 55 push %ebp <== NOT EXECUTED 10dcc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dcc3: 53 push %ebx <== NOT EXECUTED 10dcc4: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 10dcc7: ff 35 14 4f 12 00 pushl 0x124f14 <== NOT EXECUTED 10dccd: e8 52 e9 ff ff call 10c624 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 10dcd2: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10dcd5: 50 push %eax <== NOT EXECUTED 10dcd6: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dcd9: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dcdc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10dcdf: e8 f0 3d 00 00 call 111ad4 <_Heap_Extend> <== NOT EXECUTED 10dce4: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10dce6: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10dce9: ff 35 14 4f 12 00 pushl 0x124f14 <== NOT EXECUTED 10dcef: e8 78 e9 ff ff call 10c66c <_API_Mutex_Unlock> <== NOT EXECUTED 10dcf4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dcf7: 85 db test %ebx,%ebx <== NOT EXECUTED 10dcf9: 0f 94 c0 sete %al <== NOT EXECUTED return (status == HEAP_EXTEND_SUCCESSFUL); } 10dcfc: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10dcff: c9 leave <== NOT EXECUTED 10dd00: c3 ret <== NOT EXECUTED 0010bdf0 <_Protected_heap_Free>: bool _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) { 10bdf0: 55 push %ebp <== NOT EXECUTED 10bdf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bdf3: 53 push %ebx <== NOT EXECUTED 10bdf4: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED bool status; _RTEMS_Lock_allocator(); 10bdf7: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10bdfd: e8 66 ef ff ff call 10ad68 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 10be02: 5a pop %edx <== NOT EXECUTED 10be03: 59 pop %ecx <== NOT EXECUTED 10be04: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10be07: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10be0a: e8 c1 3b 00 00 call 10f9d0 <_Heap_Free> <== NOT EXECUTED 10be0f: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10be11: 58 pop %eax <== NOT EXECUTED 10be12: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10be18: e8 93 ef ff ff call 10adb0 <_API_Mutex_Unlock> <== NOT EXECUTED return status; } 10be1d: 88 d8 mov %bl,%al <== NOT EXECUTED 10be1f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10be22: c9 leave <== NOT EXECUTED 10be23: c3 ret <== NOT EXECUTED 001174a8 <_Protected_heap_Get_block_size>: bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ) { 1174a8: 55 push %ebp <== NOT EXECUTED 1174a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1174ab: 53 push %ebx <== NOT EXECUTED 1174ac: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED bool status; _RTEMS_Lock_allocator(); 1174af: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 1174b5: e8 ae 38 ff ff call 10ad68 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 1174ba: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1174bd: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1174c0: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1174c3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1174c6: e8 49 02 00 00 call 117714 <_Heap_Size_of_user_area> <== NOT EXECUTED 1174cb: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 1174cd: 58 pop %eax <== NOT EXECUTED 1174ce: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 1174d4: e8 d7 38 ff ff call 10adb0 <_API_Mutex_Unlock> <== NOT EXECUTED return status; } 1174d9: 88 d8 mov %bl,%al <== NOT EXECUTED 1174db: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1174de: c9 leave <== NOT EXECUTED 1174df: c3 ret <== NOT EXECUTED 001111d8 <_Protected_heap_Get_free_information>: bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 1111d8: 55 push %ebp <== NOT EXECUTED 1111d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1111db: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED /* * TBD: _Heap_Get_free_information does not error check or return status. */ _RTEMS_Lock_allocator(); 1111de: ff 35 b4 1f 16 00 pushl 0x161fb4 <== NOT EXECUTED 1111e4: e8 1f eb ff ff call 10fd08 <_API_Mutex_Lock> <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 1111e9: 5a pop %edx <== NOT EXECUTED 1111ea: 59 pop %ecx <== NOT EXECUTED 1111eb: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1111ee: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1111f1: e8 3e 5e 01 00 call 127034 <_Heap_Get_free_information> <== NOT EXECUTED _RTEMS_Unlock_allocator(); 1111f6: 58 pop %eax <== NOT EXECUTED 1111f7: ff 35 b4 1f 16 00 pushl 0x161fb4 <== NOT EXECUTED 1111fd: e8 4e eb ff ff call 10fd50 <_API_Mutex_Unlock> <== NOT EXECUTED return true; } 111202: b0 01 mov $0x1,%al <== NOT EXECUTED 111204: c9 leave <== NOT EXECUTED 111205: c3 ret <== NOT EXECUTED 0012731c <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 12731c: 55 push %ebp <== NOT EXECUTED 12731d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12731f: 56 push %esi <== NOT EXECUTED 127320: 53 push %ebx <== NOT EXECUTED 127321: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 127324: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Heap_Get_information_status status; if ( !the_heap ) 127327: 85 f6 test %esi,%esi <== NOT EXECUTED 127329: 74 39 je 127364 <_Protected_heap_Get_information+0x48> <== NOT EXECUTED return false; if ( !the_info ) 12732b: 85 db test %ebx,%ebx <== NOT EXECUTED 12732d: 74 35 je 127364 <_Protected_heap_Get_information+0x48> <== NOT EXECUTED return false; _RTEMS_Lock_allocator(); 12732f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 127332: ff 35 b4 1f 16 00 pushl 0x161fb4 <== NOT EXECUTED 127338: e8 cb 89 fe ff call 10fd08 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Get_information( the_heap, the_info ); 12733d: 5a pop %edx <== NOT EXECUTED 12733e: 59 pop %ecx <== NOT EXECUTED 12733f: 53 push %ebx <== NOT EXECUTED 127340: 56 push %esi <== NOT EXECUTED 127341: e8 3e 8e 00 00 call 130184 <_Heap_Get_information> <== NOT EXECUTED 127346: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 127348: 58 pop %eax <== NOT EXECUTED 127349: ff 35 b4 1f 16 00 pushl 0x161fb4 <== NOT EXECUTED 12734f: e8 fc 89 fe ff call 10fd50 <_API_Mutex_Unlock> <== NOT EXECUTED if ( status == HEAP_GET_INFORMATION_SUCCESSFUL ) 127354: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 127357: 85 db test %ebx,%ebx <== NOT EXECUTED 127359: 0f 94 c0 sete %al <== NOT EXECUTED return true; return false; } 12735c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12735f: 5b pop %ebx <== NOT EXECUTED 127360: 5e pop %esi <== NOT EXECUTED 127361: c9 leave <== NOT EXECUTED 127362: c3 ret <== NOT EXECUTED 127363: 90 nop <== NOT EXECUTED _RTEMS_Lock_allocator(); status = _Heap_Get_information( the_heap, the_info ); _RTEMS_Unlock_allocator(); if ( status == HEAP_GET_INFORMATION_SUCCESSFUL ) 127364: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; return false; } 127366: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 127369: 5b pop %ebx <== NOT EXECUTED 12736a: 5e pop %esi <== NOT EXECUTED 12736b: c9 leave <== NOT EXECUTED 12736c: c3 ret <== NOT EXECUTED 001174e0 <_Protected_heap_Resize_block>: bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ) { 1174e0: 55 push %ebp <== NOT EXECUTED 1174e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1174e3: 53 push %ebx <== NOT EXECUTED 1174e4: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Heap_Resize_status status; uint32_t old_mem_size; uint32_t avail_mem_size; _RTEMS_Lock_allocator(); 1174e7: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 1174ed: e8 76 38 ff ff call 10ad68 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Resize_block( 1174f2: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1174f5: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 1174f8: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1174fb: 50 push %eax <== NOT EXECUTED 1174fc: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1174ff: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 117502: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 117505: e8 1e 00 00 00 call 117528 <_Heap_Resize_block> <== NOT EXECUTED 11750a: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_heap, starting_address, size, &old_mem_size, &avail_mem_size ); _RTEMS_Unlock_allocator(); 11750c: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 11750f: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 117515: e8 96 38 ff ff call 10adb0 <_API_Mutex_Unlock> <== NOT EXECUTED 11751a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11751d: 85 db test %ebx,%ebx <== NOT EXECUTED 11751f: 0f 94 c0 sete %al <== NOT EXECUTED return (status == HEAP_RESIZE_SUCCESSFUL); } 117522: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 117525: c9 leave <== NOT EXECUTED 117526: c3 ret <== NOT EXECUTED 0010de3c <_Protected_heap_Walk>: bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 10de3c: 55 push %ebp <== NOT EXECUTED 10de3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10de3f: 57 push %edi <== NOT EXECUTED 10de40: 56 push %esi <== NOT EXECUTED 10de41: 53 push %ebx <== NOT EXECUTED 10de42: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10de45: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10de48: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10de4b: 8a 5d 10 mov 0x10(%ebp),%bl <== NOT EXECUTED * then it is forbidden to lock a mutex. But since we are inside * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( !_Thread_Dispatch_disable_level ) { 10de4e: a1 58 4e 12 00 mov 0x124e58,%eax <== NOT EXECUTED 10de53: 85 c0 test %eax,%eax <== NOT EXECUTED 10de55: 74 19 je 10de70 <_Protected_heap_Walk+0x34> <== NOT EXECUTED _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 10de57: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10de5a: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 10de5d: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10de60: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED } return status; } 10de63: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10de66: 5b pop %ebx <== NOT EXECUTED 10de67: 5e pop %esi <== NOT EXECUTED 10de68: 5f pop %edi <== NOT EXECUTED 10de69: c9 leave <== NOT EXECUTED if ( !_Thread_Dispatch_disable_level ) { _RTEMS_Lock_allocator(); status = _Heap_Walk( the_heap, source, do_dump ); _RTEMS_Unlock_allocator(); } else { status = _Heap_Walk( the_heap, source, do_dump ); 10de6a: e9 49 3e 00 00 jmp 111cb8 <_Heap_Walk> <== NOT EXECUTED 10de6f: 90 nop <== NOT EXECUTED * a critical section, it should be safe to walk it unlocked. * * NOTE: Dispatching is also disabled during initialization. */ if ( !_Thread_Dispatch_disable_level ) { _RTEMS_Lock_allocator(); 10de70: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10de73: ff 35 14 4f 12 00 pushl 0x124f14 <== NOT EXECUTED 10de79: e8 a6 e7 ff ff call 10c624 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Walk( the_heap, source, do_dump ); 10de7e: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10de81: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10de84: 50 push %eax <== NOT EXECUTED 10de85: 56 push %esi <== NOT EXECUTED 10de86: 57 push %edi <== NOT EXECUTED 10de87: e8 2c 3e 00 00 call 111cb8 <_Heap_Walk> <== NOT EXECUTED 10de8c: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10de8e: 58 pop %eax <== NOT EXECUTED 10de8f: ff 35 14 4f 12 00 pushl 0x124f14 <== NOT EXECUTED 10de95: e8 d2 e7 ff ff call 10c66c <_API_Mutex_Unlock> <== NOT EXECUTED 10de9a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { status = _Heap_Walk( the_heap, source, do_dump ); } return status; } 10de9d: 88 d8 mov %bl,%al <== NOT EXECUTED 10de9f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dea2: 5b pop %ebx <== NOT EXECUTED 10dea3: 5e pop %esi <== NOT EXECUTED 10dea4: 5f pop %edi <== NOT EXECUTED 10dea5: c9 leave <== NOT EXECUTED 10dea6: c3 ret <== NOT EXECUTED 0010abb0 <_RTEMS_API_Initialize>: */ void _RTEMS_API_Initialize( rtems_configuration_table *configuration_table ) { 10abb0: 55 push %ebp <== NOT EXECUTED 10abb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10abb3: 53 push %ebx <== NOT EXECUTED 10abb4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED rtems_api_configuration_table *api_configuration; api_configuration = configuration_table->RTEMS_api_configuration; 10abb7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10abba: 8b 58 40 mov 0x40(%eax),%ebx <== NOT EXECUTED _Objects_Information_table[OBJECTS_CLASSIC_API] = _RTEMS_Objects; 10abbd: c7 05 94 f7 11 00 60 movl $0x11fd60,0x11f794 <== NOT EXECUTED 10abc4: fd 11 00 <== NOT EXECUTED _Attributes_Handler_initialization(); _Interrupt_Manager_initialization(); 10abc7: e8 1c 47 00 00 call 10f2e8 <_Interrupt_Manager_initialization> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) _Multiprocessing_Manager_initialization(); #endif _RTEMS_tasks_Manager_initialization( api_configuration->maximum_tasks ); 10abcc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10abcf: ff 33 pushl (%ebx) <== NOT EXECUTED 10abd1: e8 8a 48 00 00 call 10f460 <_RTEMS_tasks_Manager_initialization> <== NOT EXECUTED _Timer_Manager_initialization( api_configuration->maximum_timers ); 10abd6: 58 pop %eax <== NOT EXECUTED 10abd7: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10abda: e8 ad 47 00 00 call 10f38c <_Timer_Manager_initialization> <== NOT EXECUTED _Signal_Manager_initialization(); 10abdf: e8 04 48 00 00 call 10f3e8 <_Signal_Manager_initialization> <== NOT EXECUTED _Event_Manager_initialization(); 10abe4: e8 ef 46 00 00 call 10f2d8 <_Event_Manager_initialization> <== NOT EXECUTED _Message_queue_Manager_initialization( 10abe9: 58 pop %eax <== NOT EXECUTED 10abea: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10abed: e8 fe 46 00 00 call 10f2f0 <_Message_queue_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_message_queues ); _Semaphore_Manager_initialization( api_configuration->maximum_semaphores ); 10abf2: 58 pop %eax <== NOT EXECUTED 10abf3: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10abf6: e8 c9 47 00 00 call 10f3c4 <_Semaphore_Manager_initialization> <== NOT EXECUTED _Partition_Manager_initialization( api_configuration->maximum_partitions ); 10abfb: 58 pop %eax <== NOT EXECUTED 10abfc: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 10abff: e8 14 47 00 00 call 10f318 <_Partition_Manager_initialization> <== NOT EXECUTED _Region_Manager_initialization( api_configuration->maximum_regions ); 10ac04: 59 pop %ecx <== NOT EXECUTED 10ac05: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10ac08: e8 57 47 00 00 call 10f364 <_Region_Manager_initialization> <== NOT EXECUTED _Dual_ported_memory_Manager_initialization( api_configuration->maximum_ports); 10ac0d: 5a pop %edx <== NOT EXECUTED 10ac0e: ff 73 1c pushl 0x1c(%ebx) <== NOT EXECUTED 10ac11: e8 9e 46 00 00 call 10f2b4 <_Dual_ported_memory_Manager_initialization> <== NOT EXECUTED _Rate_monotonic_Manager_initialization( api_configuration->maximum_periods ); 10ac16: 58 pop %eax <== NOT EXECUTED 10ac17: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10ac1a: e8 1d 47 00 00 call 10f33c <_Rate_monotonic_Manager_initialization> <== NOT EXECUTED _Barrier_Manager_initialization( api_configuration->maximum_barriers ); 10ac1f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac22: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 10ac25: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10ac28: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ac2b: c9 leave <== NOT EXECUTED _Dual_ported_memory_Manager_initialization( api_configuration->maximum_ports); _Rate_monotonic_Manager_initialization( api_configuration->maximum_periods ); _Barrier_Manager_initialization( api_configuration->maximum_barriers ); 10ac2c: e9 5f 46 00 00 jmp 10f290 <_Barrier_Manager_initialization> <== NOT EXECUTED 0010f5f4 <_RTEMS_Tasks_Invoke_task_variable_dtor>: void _RTEMS_Tasks_Invoke_task_variable_dtor( Thread_Control *the_thread, rtems_task_variable_t *tvp ) { 10f5f4: 55 push %ebp <== NOT EXECUTED 10f5f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f5f7: 56 push %esi <== NOT EXECUTED 10f5f8: 53 push %ebx <== NOT EXECUTED 10f5f9: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED void (*dtor)(void *); void *value; dtor = tvp->dtor; 10f5fc: 8b 4b 10 mov 0x10(%ebx),%ecx <== NOT EXECUTED if (_Thread_Is_executing(the_thread)) { 10f5ff: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10f602: 3b 05 7c f8 11 00 cmp 0x11f87c,%eax <== NOT EXECUTED 10f608: 74 1e je 10f628 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x34> <== NOT EXECUTED value = *tvp->ptr; *tvp->ptr = tvp->gval; } else { value = tvp->tval; 10f60a: 8b 73 0c mov 0xc(%ebx),%esi <== NOT EXECUTED } if ( dtor ) 10f60d: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f60f: 74 09 je 10f61a <_RTEMS_Tasks_Invoke_task_variable_dtor+0x26> <== NOT EXECUTED (*dtor)(value); 10f611: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f614: 56 push %esi <== NOT EXECUTED 10f615: ff d1 call *%ecx <== NOT EXECUTED 10f617: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Workspace_Free(tvp); 10f61a: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 10f61d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f620: 5b pop %ebx <== NOT EXECUTED 10f621: 5e pop %esi <== NOT EXECUTED 10f622: c9 leave <== NOT EXECUTED } if ( dtor ) (*dtor)(value); _Workspace_Free(tvp); 10f623: e9 40 de ff ff jmp 10d468 <_Workspace_Free> <== NOT EXECUTED void (*dtor)(void *); void *value; dtor = tvp->dtor; if (_Thread_Is_executing(the_thread)) { value = *tvp->ptr; 10f628: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 10f62b: 8b 32 mov (%edx),%esi <== NOT EXECUTED *tvp->ptr = tvp->gval; 10f62d: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10f630: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10f632: eb d9 jmp 10f60d <_RTEMS_Tasks_Invoke_task_variable_dtor+0x19> <== NOT EXECUTED 0010f558 <_RTEMS_tasks_Create_extension>: bool _RTEMS_tasks_Create_extension( Thread_Control *executing, Thread_Control *created ) { 10f558: 55 push %ebp <== NOT EXECUTED 10f559: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f55b: 53 push %ebx <== NOT EXECUTED 10f55c: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10f55f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED /* * Notepads must be the last entry in the structure and they * can be left off if disabled in the configuration. */ to_allocate = sizeof( RTEMS_API_Control ); if ( !rtems_configuration_get_notepads_enabled() ) 10f562: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10f567: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10f56a: 80 78 04 01 cmpb $0x1,0x4(%eax) <== NOT EXECUTED 10f56e: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10f570: 83 e0 c0 and $0xffffffc0,%eax <== NOT EXECUTED 10f573: 83 c0 60 add $0x60,%eax <== NOT EXECUTED to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); 10f576: 50 push %eax <== NOT EXECUTED 10f577: e8 04 df ff ff call 10d480 <_Workspace_Allocate> <== NOT EXECUTED 10f57c: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !api ) 10f57e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f581: 85 c0 test %eax,%eax <== NOT EXECUTED 10f583: 74 67 je 10f5ec <_RTEMS_tasks_Create_extension+0x94> <== NOT EXECUTED return false; created->API_Extensions[ THREAD_API_RTEMS ] = api; 10f585: 89 83 f4 00 00 00 mov %eax,0xf4(%ebx) <== NOT EXECUTED api->pending_events = EVENT_SETS_NONE_PENDING; 10f58b: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of 10f591: c6 40 08 01 movb $0x1,0x8(%eax) <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of 10f595: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 10f59c: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) <== NOT EXECUTED * 10f5a3: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10f5aa: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10f5b1: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) <== NOT EXECUTED _ASR_Initialize( &api->Signal ); created->task_variables = NULL; 10f5b8: c7 83 04 01 00 00 00 movl $0x0,0x104(%ebx) <== NOT EXECUTED 10f5bf: 00 00 00 <== NOT EXECUTED if ( rtems_configuration_get_notepads_enabled() ) { 10f5c2: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10f5c7: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10f5ca: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10f5ce: 74 12 je 10f5e2 <_RTEMS_tasks_Create_extension+0x8a> <== NOT EXECUTED 10f5d0: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f5d2: 66 90 xchg %ax,%ax <== NOT EXECUTED for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; 10f5d4: c7 44 82 20 00 00 00 movl $0x0,0x20(%edx,%eax,4) <== NOT EXECUTED 10f5db: 00 <== NOT EXECUTED api->pending_events = EVENT_SETS_NONE_PENDING; _ASR_Initialize( &api->Signal ); created->task_variables = NULL; if ( rtems_configuration_get_notepads_enabled() ) { for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) 10f5dc: 40 inc %eax <== NOT EXECUTED 10f5dd: 83 f8 10 cmp $0x10,%eax <== NOT EXECUTED 10f5e0: 75 f2 jne 10f5d4 <_RTEMS_tasks_Create_extension+0x7c> <== NOT EXECUTED 10f5e2: b0 01 mov $0x1,%al <== NOT EXECUTED api->Notepads[i] = 0; } return true; } 10f5e4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f5e7: c9 leave <== NOT EXECUTED 10f5e8: c3 ret <== NOT EXECUTED 10f5e9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !rtems_configuration_get_notepads_enabled() ) to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); if ( !api ) 10f5ec: 31 c0 xor %eax,%eax <== NOT EXECUTED for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; } return true; } 10f5ee: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f5f1: c9 leave <== NOT EXECUTED 10f5f2: c3 ret <== NOT EXECUTED 0010f504 <_RTEMS_tasks_Delete_extension>: User_extensions_routine _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 10f504: 55 push %ebp <== NOT EXECUTED 10f505: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f507: 56 push %esi <== NOT EXECUTED 10f508: 53 push %ebx <== NOT EXECUTED 10f509: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Free per task variable memory */ tvp = deleted->task_variables; 10f50c: 8b 86 04 01 00 00 mov 0x104(%esi),%eax <== NOT EXECUTED deleted->task_variables = NULL; 10f512: c7 86 04 01 00 00 00 movl $0x0,0x104(%esi) <== NOT EXECUTED 10f519: 00 00 00 <== NOT EXECUTED while (tvp) { 10f51c: 85 c0 test %eax,%eax <== NOT EXECUTED 10f51e: 74 15 je 10f535 <_RTEMS_tasks_Delete_extension+0x31> <== NOT EXECUTED next = (rtems_task_variable_t *)tvp->next; 10f520: 8b 18 mov (%eax),%ebx <== NOT EXECUTED _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); 10f522: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f525: 50 push %eax <== NOT EXECUTED 10f526: 56 push %esi <== NOT EXECUTED 10f527: e8 c8 00 00 00 call 10f5f4 <_RTEMS_Tasks_Invoke_task_variable_dtor> <== NOT EXECUTED 10f52c: 89 d8 mov %ebx,%eax <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 10f52e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f531: 85 db test %ebx,%ebx <== NOT EXECUTED 10f533: 75 eb jne 10f520 <_RTEMS_tasks_Delete_extension+0x1c> <== NOT EXECUTED /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 10f535: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f538: ff b6 f4 00 00 00 pushl 0xf4(%esi) <== NOT EXECUTED 10f53e: e8 25 df ff ff call 10d468 <_Workspace_Free> <== NOT EXECUTED deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 10f543: c7 86 f4 00 00 00 00 movl $0x0,0xf4(%esi) <== NOT EXECUTED 10f54a: 00 00 00 <== NOT EXECUTED 10f54d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10f550: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f553: 5b pop %ebx <== NOT EXECUTED 10f554: 5e pop %esi <== NOT EXECUTED 10f555: c9 leave <== NOT EXECUTED 10f556: c3 ret <== NOT EXECUTED 0010f44c <_RTEMS_tasks_Initialize_user_tasks>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks( void ) { 10f44c: 55 push %ebp <== NOT EXECUTED 10f44d: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( _RTEMS_tasks_Initialize_user_tasks_p ) 10f44f: 8b 0d 2c b2 11 00 mov 0x11b22c,%ecx <== NOT EXECUTED 10f455: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f457: 74 03 je 10f45c <_RTEMS_tasks_Initialize_user_tasks+0x10> <== NOT EXECUTED (*_RTEMS_tasks_Initialize_user_tasks_p)(); } 10f459: c9 leave <== NOT EXECUTED */ void _RTEMS_tasks_Initialize_user_tasks( void ) { if ( _RTEMS_tasks_Initialize_user_tasks_p ) (*_RTEMS_tasks_Initialize_user_tasks_p)(); 10f45a: ff e1 jmp *%ecx <== NOT EXECUTED } 10f45c: c9 leave <== NOT EXECUTED 10f45d: c3 ret <== NOT EXECUTED 0010a76c <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 10a76c: 55 push %ebp <== NOT EXECUTED 10a76d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a76f: 57 push %edi <== NOT EXECUTED 10a770: 56 push %esi <== NOT EXECUTED 10a771: 53 push %ebx <== NOT EXECUTED 10a772: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED rtems_status_code return_value; rtems_initialization_tasks_table *user_tasks; rtems_api_configuration_table *api_configuration; api_configuration = _Configuration_Table->RTEMS_api_configuration; 10a775: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10a77a: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED /* * NOTE: This is slightly different from the Ada implementation. */ user_tasks = api_configuration->User_initialization_tasks_table; 10a77d: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED maximum = api_configuration->number_of_initialization_tasks; 10a780: 8b 78 28 mov 0x28(%eax),%edi <== NOT EXECUTED if ( !user_tasks || maximum == 0 ) 10a783: 85 d2 test %edx,%edx <== NOT EXECUTED 10a785: 74 48 je 10a7cf <_RTEMS_tasks_Initialize_user_tasks_body+0x63> <== NOT EXECUTED 10a787: 85 ff test %edi,%edi <== NOT EXECUTED 10a789: 74 44 je 10a7cf <_RTEMS_tasks_Initialize_user_tasks_body+0x63> <== NOT EXECUTED 10a78b: 89 d3 mov %edx,%ebx <== NOT EXECUTED 10a78d: 31 f6 xor %esi,%esi <== NOT EXECUTED 10a78f: 90 nop <== NOT EXECUTED return; for ( index=0 ; index < maximum ; index++ ) { return_value = rtems_task_create( 10a790: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a793: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10a796: 50 push %eax <== NOT EXECUTED 10a797: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10a79a: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 10a79d: ff 73 04 pushl 0x4(%ebx) <== NOT EXECUTED 10a7a0: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a7a3: ff 33 pushl (%ebx) <== NOT EXECUTED 10a7a5: e8 9a fd ff ff call 10a544 <== NOT EXECUTED user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 10a7aa: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a7ad: 85 c0 test %eax,%eax <== NOT EXECUTED 10a7af: 75 27 jne 10a7d8 <_RTEMS_tasks_Initialize_user_tasks_body+0x6c> <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); return_value = rtems_task_start( 10a7b1: 51 push %ecx <== NOT EXECUTED 10a7b2: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10a7b5: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10a7b8: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10a7bb: e8 24 00 00 00 call 10a7e4 <== NOT EXECUTED id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 10a7c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a7c3: 85 c0 test %eax,%eax <== NOT EXECUTED 10a7c5: 75 11 jne 10a7d8 <_RTEMS_tasks_Initialize_user_tasks_body+0x6c> <== NOT EXECUTED maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) return; for ( index=0 ; index < maximum ; index++ ) { 10a7c7: 46 inc %esi <== NOT EXECUTED 10a7c8: 83 c3 1c add $0x1c,%ebx <== NOT EXECUTED 10a7cb: 39 f7 cmp %esi,%edi <== NOT EXECUTED 10a7cd: 77 c1 ja 10a790 <_RTEMS_tasks_Initialize_user_tasks_body+0x24> <== NOT EXECUTED ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); } } 10a7cf: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a7d2: 5b pop %ebx <== NOT EXECUTED 10a7d3: 5e pop %esi <== NOT EXECUTED 10a7d4: 5f pop %edi <== NOT EXECUTED 10a7d5: c9 leave <== NOT EXECUTED 10a7d6: c3 ret <== NOT EXECUTED 10a7d7: 90 nop <== NOT EXECUTED user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); 10a7d8: 52 push %edx <== NOT EXECUTED 10a7d9: 50 push %eax <== NOT EXECUTED 10a7da: 6a 01 push $0x1 <== NOT EXECUTED 10a7dc: 6a 01 push $0x1 <== NOT EXECUTED 10a7de: e8 9d 0d 00 00 call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 0010f460 <_RTEMS_tasks_Manager_initialization>: */ void _RTEMS_tasks_Manager_initialization( uint32_t maximum_tasks ) { 10f460: 55 push %ebp <== NOT EXECUTED 10f461: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f463: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f466: 6a 04 push $0x4 <== NOT EXECUTED 10f468: 6a 00 push $0x0 <== NOT EXECUTED 10f46a: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10f46f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f472: 6a 01 push $0x1 <== NOT EXECUTED 10f474: 6a 02 push $0x2 <== NOT EXECUTED 10f476: 68 40 f7 11 00 push $0x11f740 <== NOT EXECUTED 10f47b: e8 ec c6 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED /* * Add all the extensions for this API */ _User_extensions_Add_API_set( &_RTEMS_tasks_User_extensions ); 10f480: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10f483: 68 00 d6 11 00 push $0x11d600 <== NOT EXECUTED 10f488: e8 d7 0a 00 00 call 10ff64 <_User_extensions_Add_API_set> <== NOT EXECUTED _API_extensions_Add( &_RTEMS_tasks_API_extensions ); 10f48d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f490: c7 45 08 e0 d5 11 00 movl $0x11d5e0,0x8(%ebp) <== NOT EXECUTED MP_PACKET_TASKS, _RTEMS_tasks_MP_Process_packet ); #endif } 10f497: c9 leave <== NOT EXECUTED * Add all the extensions for this API */ _User_extensions_Add_API_set( &_RTEMS_tasks_User_extensions ); _API_extensions_Add( &_RTEMS_tasks_API_extensions ); 10f498: e9 57 b8 ff ff jmp 10acf4 <_API_extensions_Add> <== NOT EXECUTED 0010f4a0 <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) { 10f4a0: 55 push %ebp <== NOT EXECUTED 10f4a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f4a3: 57 push %edi <== NOT EXECUTED 10f4a4: 56 push %esi <== NOT EXECUTED 10f4a5: 53 push %ebx <== NOT EXECUTED 10f4a6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED RTEMS_API_Control *api; ASR_Information *asr; rtems_signal_set signal_set; Modes_Control prev_mode; api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10f4a9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10f4ac: 8b b0 f4 00 00 00 mov 0xf4(%eax),%esi <== NOT EXECUTED if ( !api ) 10f4b2: 85 f6 test %esi,%esi <== NOT EXECUTED 10f4b4: 74 45 je 10f4fb <_RTEMS_tasks_Post_switch_extension+0x5b> <== NOT EXECUTED * Signal Processing */ asr = &api->Signal; _ISR_Disable( level ); 10f4b6: 9c pushf <== NOT EXECUTED 10f4b7: fa cli <== NOT EXECUTED 10f4b8: 58 pop %eax <== NOT EXECUTED signal_set = asr->signals_posted; 10f4b9: 8b 7e 14 mov 0x14(%esi),%edi <== NOT EXECUTED asr->signals_posted = 0; 10f4bc: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED _ISR_Enable( level ); 10f4c3: 50 push %eax <== NOT EXECUTED 10f4c4: 9d popf <== NOT EXECUTED if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 10f4c5: 85 ff test %edi,%edi <== NOT EXECUTED 10f4c7: 74 32 je 10f4fb <_RTEMS_tasks_Post_switch_extension+0x5b> <== NOT EXECUTED return; asr->nest_level += 1; 10f4c9: ff 46 1c incl 0x1c(%esi) <== NOT EXECUTED rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10f4cc: 50 push %eax <== NOT EXECUTED 10f4cd: 8d 5d f0 lea -0x10(%ebp),%ebx <== NOT EXECUTED 10f4d0: 53 push %ebx <== NOT EXECUTED 10f4d1: 68 ff ff 00 00 push $0xffff <== NOT EXECUTED 10f4d6: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 10f4d9: e8 ae 12 00 00 call 11078c <== NOT EXECUTED (*asr->handler)( signal_set ); 10f4de: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10f4e1: ff 56 0c call *0xc(%esi) <== NOT EXECUTED asr->nest_level -= 1; 10f4e4: ff 4e 1c decl 0x1c(%esi) <== NOT EXECUTED rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10f4e7: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10f4ea: 53 push %ebx <== NOT EXECUTED 10f4eb: 68 ff ff 00 00 push $0xffff <== NOT EXECUTED 10f4f0: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10f4f3: e8 94 12 00 00 call 11078c <== NOT EXECUTED 10f4f8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10f4fb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f4fe: 5b pop %ebx <== NOT EXECUTED 10f4ff: 5e pop %esi <== NOT EXECUTED 10f500: 5f pop %edi <== NOT EXECUTED 10f501: c9 leave <== NOT EXECUTED 10f502: c3 ret <== NOT EXECUTED 0010f3f0 <_RTEMS_tasks_Start_extension>: User_extensions_routine _RTEMS_tasks_Start_extension( Thread_Control *executing, Thread_Control *started ) { 10f3f0: 55 push %ebp <== NOT EXECUTED 10f3f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED RTEMS_API_Control *api; api = started->API_Extensions[ THREAD_API_RTEMS ]; api->pending_events = EVENT_SETS_NONE_PENDING; 10f3f3: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f3f6: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10f3fc: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED } 10f402: c9 leave <== NOT EXECUTED 10f403: c3 ret <== NOT EXECUTED 0010f404 <_RTEMS_tasks_Switch_extension>: void _RTEMS_tasks_Switch_extension( Thread_Control *executing, Thread_Control *heir ) { 10f404: 55 push %ebp <== NOT EXECUTED 10f405: 89 e5 mov %esp,%ebp <== NOT EXECUTED /* * Per Task Variables */ tvp = executing->task_variables; 10f407: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10f40a: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx <== NOT EXECUTED while (tvp) { 10f410: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f412: 74 13 je 10f427 <_RTEMS_tasks_Switch_extension+0x23> <== NOT EXECUTED tvp->tval = *tvp->ptr; 10f414: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10f417: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10f419: 89 51 0c mov %edx,0xc(%ecx) <== NOT EXECUTED *tvp->ptr = tvp->gval; 10f41c: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED 10f41f: 89 10 mov %edx,(%eax) <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 10f421: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 10f423: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f425: 75 ed jne 10f414 <_RTEMS_tasks_Switch_extension+0x10> <== NOT EXECUTED tvp->tval = *tvp->ptr; *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; 10f427: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f42a: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx <== NOT EXECUTED while (tvp) { 10f430: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f432: 74 13 je 10f447 <_RTEMS_tasks_Switch_extension+0x43> <== NOT EXECUTED tvp->gval = *tvp->ptr; 10f434: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10f437: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10f439: 89 51 08 mov %edx,0x8(%ecx) <== NOT EXECUTED *tvp->ptr = tvp->tval; 10f43c: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED 10f43f: 89 10 mov %edx,(%eax) <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 10f441: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 10f443: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f445: 75 ed jne 10f434 <_RTEMS_tasks_Switch_extension+0x30> <== NOT EXECUTED tvp->gval = *tvp->ptr; *tvp->ptr = tvp->tval; tvp = (rtems_task_variable_t *)tvp->next; } } 10f447: c9 leave <== NOT EXECUTED 10f448: c3 ret <== NOT EXECUTED 0010b0ac <_Rate_monotonic_Initiate_statistics>: #endif void _Rate_monotonic_Initiate_statistics( Rate_monotonic_Control *the_period ) { 10b0ac: 55 push %ebp <== NOT EXECUTED 10b0ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b0af: 57 push %edi <== NOT EXECUTED 10b0b0: 56 push %esi <== NOT EXECUTED 10b0b1: 53 push %ebx <== NOT EXECUTED 10b0b2: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED 10b0b5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Thread_Control *owning_thread = the_period->owner; 10b0b8: 8b 5e 50 mov 0x50(%esi),%ebx <== NOT EXECUTED #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) struct timespec uptime; _TOD_Get_uptime( &uptime ); 10b0bb: 8d 7d ec lea -0x14(%ebp),%edi <== NOT EXECUTED 10b0be: 57 push %edi <== NOT EXECUTED 10b0bf: e8 10 1a 00 00 call 10cad4 <_TOD_Get_uptime> <== NOT EXECUTED /* * Set the starting point and the CPU time used for the statistics. */ #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS the_period->time_at_period = uptime; 10b0c4: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10b0c7: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10b0ca: 89 46 44 mov %eax,0x44(%esi) <== NOT EXECUTED 10b0cd: 89 56 48 mov %edx,0x48(%esi) <== NOT EXECUTED #else the_period->time_at_period = _Watchdog_Ticks_since_boot; #endif the_period->owner_executed_at_period = owning_thread->cpu_time_used; 10b0d0: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx <== NOT EXECUTED 10b0d6: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax <== NOT EXECUTED 10b0dc: 89 46 40 mov %eax,0x40(%esi) <== NOT EXECUTED 10b0df: 89 56 3c mov %edx,0x3c(%esi) <== NOT EXECUTED * context switch. When this routine is invoked from * rtems_rate_monotonic_period, the owner will be the executing thread. * When this routine is invoked from _Rate_monotonic_Timeout, it will not. */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS if (owning_thread == _Thread_Executing) { 10b0e2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b0e5: 3b 1d 1c 40 12 00 cmp 0x12401c,%ebx <== NOT EXECUTED 10b0eb: 74 0b je 10b0f8 <_Rate_monotonic_Initiate_statistics+0x4c> <== NOT EXECUTED ); _Timespec_Add_to( &the_period->owner_executed_at_period, &ran ); } #endif } 10b0ed: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b0f0: 5b pop %ebx <== NOT EXECUTED 10b0f1: 5e pop %esi <== NOT EXECUTED 10b0f2: 5f pop %edi <== NOT EXECUTED 10b0f3: c9 leave <== NOT EXECUTED 10b0f4: c3 ret <== NOT EXECUTED 10b0f5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Adjust the CPU time used to account for the time since last * context switch. */ _Timespec_Subtract( 10b0f8: 51 push %ecx <== NOT EXECUTED 10b0f9: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 10b0fc: 53 push %ebx <== NOT EXECUTED 10b0fd: 57 push %edi <== NOT EXECUTED 10b0fe: 68 24 40 12 00 push $0x124024 <== NOT EXECUTED 10b103: e8 a8 39 00 00 call 10eab0 <_Timespec_Subtract> <== NOT EXECUTED &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timespec_Add_to( &the_period->owner_executed_at_period, &ran ); 10b108: 58 pop %eax <== NOT EXECUTED 10b109: 5a pop %edx <== NOT EXECUTED 10b10a: 53 push %ebx <== NOT EXECUTED 10b10b: 8d 46 3c lea 0x3c(%esi),%eax <== NOT EXECUTED 10b10e: 50 push %eax <== NOT EXECUTED 10b10f: e8 a8 38 00 00 call 10e9bc <_Timespec_Add_to> <== NOT EXECUTED 10b114: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b117: eb d4 jmp 10b0ed <_Rate_monotonic_Initiate_statistics+0x41> <== NOT EXECUTED 0010f33c <_Rate_monotonic_Manager_initialization>: */ void _Rate_monotonic_Manager_initialization( uint32_t maximum_periods ) { 10f33c: 55 push %ebp <== NOT EXECUTED 10f33d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f33f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f342: 6a 04 push $0x4 <== NOT EXECUTED 10f344: 6a 00 push $0x0 <== NOT EXECUTED 10f346: 68 8c 00 00 00 push $0x8c <== NOT EXECUTED 10f34b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f34e: 6a 08 push $0x8 <== NOT EXECUTED 10f350: 6a 02 push $0x2 <== NOT EXECUTED 10f352: 68 00 03 12 00 push $0x120300 <== NOT EXECUTED 10f357: e8 10 c8 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f35c: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10f35f: c9 leave <== NOT EXECUTED 10f360: c3 ret <== NOT EXECUTED 0010b6e0 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 10b6e0: 55 push %ebp <== NOT EXECUTED 10b6e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b6e3: 53 push %ebx <== NOT EXECUTED 10b6e4: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10b6e7: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10b6ea: 50 push %eax <== NOT EXECUTED 10b6eb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b6ee: 68 60 3e 12 00 push $0x123e60 <== NOT EXECUTED 10b6f3: e8 48 1d 00 00 call 10d440 <_Objects_Get> <== NOT EXECUTED 10b6f8: 89 c3 mov %eax,%ebx <== NOT EXECUTED /* * When we get here, the Timer is already off the chain so we do not * have to worry about that -- hence no _Watchdog_Remove(). */ the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 10b6fa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b6fd: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10b700: 85 c0 test %eax,%eax <== NOT EXECUTED 10b702: 75 21 jne 10b725 <_Rate_monotonic_Timeout+0x45> <== NOT EXECUTED case OBJECTS_LOCAL: the_thread = the_period->owner; 10b704: 8b 53 50 mov 0x50(%ebx),%edx <== NOT EXECUTED if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10b707: f6 42 11 40 testb $0x40,0x11(%edx) <== NOT EXECUTED 10b70b: 75 1f jne 10b72c <_Rate_monotonic_Timeout+0x4c> <== NOT EXECUTED _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else if ( the_period->state == RATE_MONOTONIC_OWNER_IS_BLOCKING ) { 10b70d: 83 7b 38 01 cmpl $0x1,0x38(%ebx) <== NOT EXECUTED 10b711: 74 35 je 10b748 <_Rate_monotonic_Timeout+0x68> <== NOT EXECUTED _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else the_period->state = RATE_MONOTONIC_EXPIRED; 10b713: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx) <== NOT EXECUTED 10b71a: a1 58 3f 12 00 mov 0x123f58,%eax <== NOT EXECUTED 10b71f: 48 dec %eax <== NOT EXECUTED 10b720: a3 58 3f 12 00 mov %eax,0x123f58 <== NOT EXECUTED case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10b725: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b728: c9 leave <== NOT EXECUTED 10b729: c3 ret <== NOT EXECUTED 10b72a: 66 90 xchg %ax,%ax <== NOT EXECUTED the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: the_thread = the_period->owner; if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10b72c: 8b 42 20 mov 0x20(%edx),%eax <== NOT EXECUTED 10b72f: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10b732: 75 d9 jne 10b70d <_Rate_monotonic_Timeout+0x2d> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10b734: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b737: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10b73c: 52 push %edx <== NOT EXECUTED 10b73d: e8 9a 21 00 00 call 10d8dc <_Thread_Clear_state> <== NOT EXECUTED the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 10b742: 59 pop %ecx <== NOT EXECUTED 10b743: eb 0d jmp 10b752 <_Rate_monotonic_Timeout+0x72> <== NOT EXECUTED 10b745: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _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; 10b748: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) <== NOT EXECUTED _Rate_monotonic_Initiate_statistics( the_period ); 10b74f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b752: 53 push %ebx <== NOT EXECUTED 10b753: e8 54 f9 ff ff call 10b0ac <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10b758: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10b75b: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10b75e: 58 pop %eax <== NOT EXECUTED 10b75f: 5a pop %edx <== NOT EXECUTED 10b760: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10b763: 50 push %eax <== NOT EXECUTED 10b764: 68 3c 40 12 00 push $0x12403c <== NOT EXECUTED 10b769: e8 ea 35 00 00 call 10ed58 <_Watchdog_Insert> <== NOT EXECUTED 10b76e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b771: eb a7 jmp 10b71a <_Rate_monotonic_Timeout+0x3a> <== NOT EXECUTED 0010b11c <_Rate_monotonic_Update_statistics>: } void _Rate_monotonic_Update_statistics( Rate_monotonic_Control *the_period ) { 10b11c: 55 push %ebp <== NOT EXECUTED 10b11d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b11f: 57 push %edi <== NOT EXECUTED 10b120: 56 push %esi <== NOT EXECUTED 10b121: 53 push %ebx <== NOT EXECUTED 10b122: 83 ec 48 sub $0x48,%esp <== NOT EXECUTED 10b125: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED struct timespec uptime; /* * Obtain the current time since boot */ _TOD_Get_uptime( &uptime ); 10b128: 8d 7d dc lea -0x24(%ebp),%edi <== NOT EXECUTED 10b12b: 57 push %edi <== NOT EXECUTED 10b12c: e8 a3 19 00 00 call 10cad4 <_TOD_Get_uptime> <== NOT EXECUTED /* * Update the counts. */ stats = &the_period->Statistics; stats->count++; 10b131: ff 46 54 incl 0x54(%esi) <== NOT EXECUTED if ( the_period->state == RATE_MONOTONIC_EXPIRED ) 10b134: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b137: 83 7e 38 04 cmpl $0x4,0x38(%esi) <== NOT EXECUTED 10b13b: 0f 84 27 01 00 00 je 10b268 <_Rate_monotonic_Update_statistics+0x14c> <== NOT EXECUTED /* * Grab basic information for time statistics. */ #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 10b141: 50 push %eax <== NOT EXECUTED 10b142: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10b145: 50 push %eax <== NOT EXECUTED 10b146: 57 push %edi <== NOT EXECUTED 10b147: 8d 46 44 lea 0x44(%esi),%eax <== NOT EXECUTED 10b14a: 50 push %eax <== NOT EXECUTED 10b14b: e8 60 39 00 00 call 10eab0 <_Timespec_Subtract> <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { rtems_thread_cpu_usage_t ran, used; /* Grab CPU usage when the thread got switched in */ used = _Thread_Executing->cpu_time_used; 10b150: a1 1c 40 12 00 mov 0x12401c,%eax <== NOT EXECUTED 10b155: 8b 90 84 00 00 00 mov 0x84(%eax),%edx <== NOT EXECUTED 10b15b: 8b 80 88 00 00 00 mov 0x88(%eax),%eax <== NOT EXECUTED 10b161: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 10b164: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED /* How much time time since last context switch */ _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 10b167: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10b16a: 8d 5d d4 lea -0x2c(%ebp),%ebx <== NOT EXECUTED 10b16d: 53 push %ebx <== NOT EXECUTED 10b16e: 57 push %edi <== NOT EXECUTED 10b16f: 68 24 40 12 00 push $0x124024 <== NOT EXECUTED 10b174: e8 37 39 00 00 call 10eab0 <_Timespec_Subtract> <== NOT EXECUTED /* executed += ran */ _Timespec_Add_to( &used, &ran ); 10b179: 59 pop %ecx <== NOT EXECUTED 10b17a: 5f pop %edi <== NOT EXECUTED 10b17b: 53 push %ebx <== NOT EXECUTED 10b17c: 8d 5d cc lea -0x34(%ebp),%ebx <== NOT EXECUTED 10b17f: 53 push %ebx <== NOT EXECUTED 10b180: e8 37 38 00 00 call 10e9bc <_Timespec_Add_to> <== NOT EXECUTED /* partial period, cpu usage info reset while executing. Throw away */ if (_Timespec_Less_than( &used, &the_period->owner_executed_at_period)) 10b185: 8d 7e 3c lea 0x3c(%esi),%edi <== NOT EXECUTED 10b188: 58 pop %eax <== NOT EXECUTED 10b189: 5a pop %edx <== NOT EXECUTED 10b18a: 57 push %edi <== NOT EXECUTED 10b18b: 53 push %ebx <== NOT EXECUTED 10b18c: e8 fb 38 00 00 call 10ea8c <_Timespec_Less_than> <== NOT EXECUTED 10b191: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b194: 84 c0 test %al,%al <== NOT EXECUTED 10b196: 74 08 je 10b1a0 <_Rate_monotonic_Update_statistics+0x84> <== NOT EXECUTED stats->min_wall_time = since_last_period; if ( _Timespec_Greater_than( &since_last_period, &stats->max_wall_time ) ) stats->max_wall_time = since_last_period; #endif } 10b198: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b19b: 5b pop %ebx <== NOT EXECUTED 10b19c: 5e pop %esi <== NOT EXECUTED 10b19d: 5f pop %edi <== NOT EXECUTED 10b19e: c9 leave <== NOT EXECUTED 10b19f: c3 ret <== NOT EXECUTED /* partial period, cpu usage info reset while executing. Throw away */ if (_Timespec_Less_than( &used, &the_period->owner_executed_at_period)) return; /* executed = current cpu usage - value at start of period */ _Timespec_Subtract( 10b1a0: 50 push %eax <== NOT EXECUTED 10b1a1: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10b1a4: 50 push %eax <== NOT EXECUTED 10b1a5: 53 push %ebx <== NOT EXECUTED 10b1a6: 57 push %edi <== NOT EXECUTED 10b1a7: e8 04 39 00 00 call 10eab0 <_Timespec_Subtract> <== NOT EXECUTED /* * Update CPU time */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _Timespec_Add_to( &stats->total_cpu_time, &executed ); 10b1ac: 59 pop %ecx <== NOT EXECUTED 10b1ad: 5b pop %ebx <== NOT EXECUTED 10b1ae: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10b1b1: 50 push %eax <== NOT EXECUTED 10b1b2: 8d 46 6c lea 0x6c(%esi),%eax <== NOT EXECUTED 10b1b5: 50 push %eax <== NOT EXECUTED 10b1b6: e8 01 38 00 00 call 10e9bc <_Timespec_Add_to> <== NOT EXECUTED if ( _Timespec_Less_than( &executed, &stats->min_cpu_time ) ) 10b1bb: 58 pop %eax <== NOT EXECUTED 10b1bc: 5a pop %edx <== NOT EXECUTED 10b1bd: 8d 46 5c lea 0x5c(%esi),%eax <== NOT EXECUTED 10b1c0: 50 push %eax <== NOT EXECUTED 10b1c1: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10b1c4: 50 push %eax <== NOT EXECUTED 10b1c5: e8 c2 38 00 00 call 10ea8c <_Timespec_Less_than> <== NOT EXECUTED 10b1ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b1cd: 84 c0 test %al,%al <== NOT EXECUTED 10b1cf: 74 0c je 10b1dd <_Rate_monotonic_Update_statistics+0xc1> <== NOT EXECUTED stats->min_cpu_time = executed; 10b1d1: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10b1d4: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10b1d7: 89 46 5c mov %eax,0x5c(%esi) <== NOT EXECUTED 10b1da: 89 56 60 mov %edx,0x60(%esi) <== NOT EXECUTED if ( _Timespec_Greater_than( &executed, &stats->max_cpu_time ) ) 10b1dd: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b1e0: 8d 46 64 lea 0x64(%esi),%eax <== NOT EXECUTED 10b1e3: 50 push %eax <== NOT EXECUTED 10b1e4: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10b1e7: 50 push %eax <== NOT EXECUTED 10b1e8: e8 7b 38 00 00 call 10ea68 <_Timespec_Greater_than> <== NOT EXECUTED 10b1ed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b1f0: 84 c0 test %al,%al <== NOT EXECUTED 10b1f2: 74 0c je 10b200 <_Rate_monotonic_Update_statistics+0xe4> <== NOT EXECUTED stats->max_cpu_time = executed; 10b1f4: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10b1f7: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10b1fa: 89 46 64 mov %eax,0x64(%esi) <== NOT EXECUTED 10b1fd: 89 56 68 mov %edx,0x68(%esi) <== NOT EXECUTED stats->min_wall_time = since_last_period; if ( since_last_period > stats->max_wall_time ) stats->max_wall_time = since_last_period; #else _Timespec_Add_to( &stats->total_wall_time, &since_last_period ); 10b200: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b203: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10b206: 50 push %eax <== NOT EXECUTED 10b207: 8d 86 84 00 00 00 lea 0x84(%esi),%eax <== NOT EXECUTED 10b20d: 50 push %eax <== NOT EXECUTED 10b20e: e8 a9 37 00 00 call 10e9bc <_Timespec_Add_to> <== NOT EXECUTED if ( _Timespec_Less_than( &since_last_period, &stats->min_wall_time ) ) 10b213: 5b pop %ebx <== NOT EXECUTED 10b214: 5f pop %edi <== NOT EXECUTED 10b215: 8d 46 74 lea 0x74(%esi),%eax <== NOT EXECUTED 10b218: 50 push %eax <== NOT EXECUTED 10b219: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10b21c: 50 push %eax <== NOT EXECUTED 10b21d: e8 6a 38 00 00 call 10ea8c <_Timespec_Less_than> <== NOT EXECUTED 10b222: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b225: 84 c0 test %al,%al <== NOT EXECUTED 10b227: 74 0c je 10b235 <_Rate_monotonic_Update_statistics+0x119> <== NOT EXECUTED stats->min_wall_time = since_last_period; 10b229: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10b22c: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10b22f: 89 46 74 mov %eax,0x74(%esi) <== NOT EXECUTED 10b232: 89 56 78 mov %edx,0x78(%esi) <== NOT EXECUTED if ( _Timespec_Greater_than( &since_last_period, &stats->max_wall_time ) ) 10b235: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b238: 8d 46 7c lea 0x7c(%esi),%eax <== NOT EXECUTED 10b23b: 50 push %eax <== NOT EXECUTED 10b23c: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10b23f: 50 push %eax <== NOT EXECUTED 10b240: e8 23 38 00 00 call 10ea68 <_Timespec_Greater_than> <== NOT EXECUTED 10b245: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b248: 84 c0 test %al,%al <== NOT EXECUTED 10b24a: 0f 84 48 ff ff ff je 10b198 <_Rate_monotonic_Update_statistics+0x7c> <== NOT EXECUTED stats->max_wall_time = since_last_period; 10b250: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10b253: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10b256: 89 46 7c mov %eax,0x7c(%esi) <== NOT EXECUTED 10b259: 89 96 80 00 00 00 mov %edx,0x80(%esi) <== NOT EXECUTED #endif } 10b25f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b262: 5b pop %ebx <== NOT EXECUTED 10b263: 5e pop %esi <== NOT EXECUTED 10b264: 5f pop %edi <== NOT EXECUTED 10b265: c9 leave <== NOT EXECUTED 10b266: c3 ret <== NOT EXECUTED 10b267: 90 nop <== NOT EXECUTED */ stats = &the_period->Statistics; stats->count++; if ( the_period->state == RATE_MONOTONIC_EXPIRED ) stats->missed_count++; 10b268: ff 46 58 incl 0x58(%esi) <== NOT EXECUTED 10b26b: e9 d1 fe ff ff jmp 10b141 <_Rate_monotonic_Update_statistics+0x25> <== NOT EXECUTED 0010f364 <_Region_Manager_initialization>: */ void _Region_Manager_initialization( uint32_t maximum_regions ) { 10f364: 55 push %ebp <== NOT EXECUTED 10f365: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f367: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f36a: 6a 04 push $0x4 <== NOT EXECUTED 10f36c: 6a 00 push $0x0 <== NOT EXECUTED 10f36e: 68 c0 00 00 00 push $0xc0 <== NOT EXECUTED 10f373: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f376: 6a 06 push $0x6 <== NOT EXECUTED 10f378: 6a 02 push $0x2 <== NOT EXECUTED 10f37a: 68 40 03 12 00 push $0x120340 <== NOT EXECUTED 10f37f: e8 e8 c7 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f384: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_REGION, 0 /* XXX _Region_MP_Process_packet */ ); #endif } 10f387: c9 leave <== NOT EXECUTED 10f388: c3 ret <== NOT EXECUTED 0011a928 <_Region_Process_queue>: */ void _Region_Process_queue( Region_Control *the_region ) { 11a928: 55 push %ebp <== NOT EXECUTED 11a929: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11a92b: 57 push %edi <== NOT EXECUTED 11a92c: 56 push %esi <== NOT EXECUTED 11a92d: 53 push %ebx <== NOT EXECUTED 11a92e: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 11a931: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 11a934: a1 78 6d 13 00 mov 0x136d78,%eax <== NOT EXECUTED 11a939: 40 inc %eax <== NOT EXECUTED 11a93a: a3 78 6d 13 00 mov %eax,0x136d78 <== NOT EXECUTED * 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(); 11a93f: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 11a945: e8 8e ab ff ff call 1154d8 <_API_Mutex_Unlock> <== NOT EXECUTED /* * 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 ); 11a94a: 8d 7e 10 lea 0x10(%esi),%edi <== NOT EXECUTED /** * This function attempts to allocate a block of @a size bytes from * @a the_heap. If insufficient memory is free in @a the_heap to allocate * a block of the requested size, then NULL is returned. * 11a94d: 8d 46 68 lea 0x68(%esi),%eax <== NOT EXECUTED 11a950: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 11a953: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11a956: eb 33 jmp 11a98b <_Region_Process_queue+0x63> <== NOT EXECUTED 11a958: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11a95b: ff 70 24 pushl 0x24(%eax) <== NOT EXECUTED 11a95e: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 11a961: e8 66 b5 ff ff call 115ecc <_Heap_Allocate> <== NOT EXECUTED 11a966: 89 c2 mov %eax,%edx <== NOT EXECUTED the_segment = (void **) _Region_Allocate_segment( the_region, the_thread->Wait.count ); if ( the_segment == NULL ) 11a968: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11a96b: 85 c0 test %eax,%eax <== NOT EXECUTED 11a96d: 74 2e je 11a99d <_Region_Process_queue+0x75> <== NOT EXECUTED break; *(void **)the_thread->Wait.return_argument = the_segment; 11a96f: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 11a972: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_region->number_of_used_blocks += 1; 11a974: ff 46 64 incl 0x64(%esi) <== NOT EXECUTED _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); 11a977: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11a97a: 53 push %ebx <== NOT EXECUTED 11a97b: 57 push %edi <== NOT EXECUTED 11a97c: e8 47 06 00 00 call 11afc8 <_Thread_queue_Extract> <== NOT EXECUTED the_thread->Wait.return_code = RTEMS_SUCCESSFUL; 11a981: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED 11a988: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * 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 ); 11a98b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11a98e: 57 push %edi <== NOT EXECUTED 11a98f: e8 28 07 00 00 call 11b0bc <_Thread_queue_First> <== NOT EXECUTED 11a994: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( the_thread == NULL ) 11a996: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11a999: 85 c0 test %eax,%eax <== NOT EXECUTED 11a99b: 75 bb jne 11a958 <_Region_Process_queue+0x30> <== NOT EXECUTED the_region->number_of_used_blocks += 1; _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); the_thread->Wait.return_code = RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); } 11a99d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11a9a0: 5b pop %ebx <== NOT EXECUTED 11a9a1: 5e pop %esi <== NOT EXECUTED 11a9a2: 5f pop %edi <== NOT EXECUTED 11a9a3: c9 leave <== NOT EXECUTED *(void **)the_thread->Wait.return_argument = the_segment; the_region->number_of_used_blocks += 1; _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); the_thread->Wait.return_code = RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 11a9a4: e9 db ca ff ff jmp 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 0010f3c4 <_Semaphore_Manager_initialization>: */ void _Semaphore_Manager_initialization( uint32_t maximum_semaphores ) { 10f3c4: 55 push %ebp <== NOT EXECUTED 10f3c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f3c7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f3ca: 6a 04 push $0x4 <== NOT EXECUTED 10f3cc: 6a 00 push $0x0 <== NOT EXECUTED 10f3ce: 6a 78 push $0x78 <== NOT EXECUTED 10f3d0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f3d3: 6a 03 push $0x3 <== NOT EXECUTED 10f3d5: 6a 02 push $0x2 <== NOT EXECUTED 10f3d7: 68 00 f7 11 00 push $0x11f700 <== NOT EXECUTED 10f3dc: e8 8b c7 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10f3e1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_SEMAPHORE, _Semaphore_MP_Process_packet ); #endif } 10f3e4: c9 leave <== NOT EXECUTED 10f3e5: c3 ret <== NOT EXECUTED 0010a524 <_Semaphore_Translate_core_mutex_return_code>: }; rtems_status_code _Semaphore_Translate_core_mutex_return_code ( uint32_t status ) { 10a524: 55 push %ebp <== NOT EXECUTED 10a525: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a527: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a52a: 8b 04 85 fc 8f 11 00 mov 0x118ffc(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( status > CORE_MUTEX_STATUS_LAST ) return RTEMS_INTERNAL_ERROR; #endif return _Semaphore_Translate_core_mutex_return_code_[status]; } 10a531: c9 leave <== NOT EXECUTED 10a532: c3 ret <== NOT EXECUTED 0010a534 <_Semaphore_Translate_core_semaphore_return_code>: }; rtems_status_code _Semaphore_Translate_core_semaphore_return_code ( uint32_t status ) { 10a534: 55 push %ebp <== NOT EXECUTED 10a535: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a537: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a53a: 8b 04 85 18 90 11 00 mov 0x119018(,%eax,4),%eax <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( status > CORE_SEMAPHORE_STATUS_LAST ) return RTEMS_INTERNAL_ERROR; #endif return _Semaphore_Translate_core_semaphore_return_code_[status]; } 10a541: c9 leave <== NOT EXECUTED 10a542: c3 ret <== NOT EXECUTED 0010f3e8 <_Signal_Manager_initialization>: * * Output parameters: NONE */ void _Signal_Manager_initialization( void ) { 10f3e8: 55 push %ebp <== NOT EXECUTED 10f3e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED _MPCI_Register_packet_processor( MP_PACKET_SIGNAL, _Signal_MP_Process_packet ); #endif } 10f3eb: c9 leave <== NOT EXECUTED 10f3ec: c3 ret <== NOT EXECUTED 0010b29c <_TOD_Get>: */ void _TOD_Get( struct timespec *time ) { 10b29c: 55 push %ebp <== NOT EXECUTED 10b29d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b29f: 56 push %esi <== NOT EXECUTED 10b2a0: 53 push %ebx <== NOT EXECUTED 10b2a1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10b2a4: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED ISR_Level level; struct timespec offset; /* assume time checked by caller */ offset.tv_sec = 0; 10b2a7: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED offset.tv_nsec = 0; 10b2ae: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED /* _TOD_Now is a proper POSIX time */ _ISR_Disable( level ); 10b2b5: 9c pushf <== NOT EXECUTED 10b2b6: fa cli <== NOT EXECUTED 10b2b7: 5b pop %ebx <== NOT EXECUTED *time = _TOD_Now; 10b2b8: a1 4c f8 11 00 mov 0x11f84c,%eax <== NOT EXECUTED 10b2bd: 8b 15 50 f8 11 00 mov 0x11f850,%edx <== NOT EXECUTED 10b2c3: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10b2c5: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED if ( _Watchdog_Nanoseconds_since_tick_handler ) 10b2c8: a1 88 f9 11 00 mov 0x11f988,%eax <== NOT EXECUTED 10b2cd: 85 c0 test %eax,%eax <== NOT EXECUTED 10b2cf: 74 05 je 10b2d6 <_TOD_Get+0x3a> <== NOT EXECUTED offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)(); 10b2d1: ff d0 call *%eax <== NOT EXECUTED 10b2d3: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED _ISR_Enable( level ); 10b2d6: 53 push %ebx <== NOT EXECUTED 10b2d7: 9d popf <== NOT EXECUTED _Timespec_Add_to( time, &offset ); 10b2d8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b2db: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b2de: 50 push %eax <== NOT EXECUTED 10b2df: 56 push %esi <== NOT EXECUTED 10b2e0: e8 97 1c 00 00 call 10cf7c <_Timespec_Add_to> <== NOT EXECUTED 10b2e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b2e8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b2eb: 5b pop %ebx <== NOT EXECUTED 10b2ec: 5e pop %esi <== NOT EXECUTED 10b2ed: c9 leave <== NOT EXECUTED 10b2ee: c3 ret <== NOT EXECUTED 0010f8e8 <_TOD_Get_uptime>: */ void _TOD_Get_uptime( struct timespec *uptime ) { 10f8e8: 55 push %ebp <== NOT EXECUTED 10f8e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f8eb: 56 push %esi <== NOT EXECUTED 10f8ec: 53 push %ebx <== NOT EXECUTED 10f8ed: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10f8f0: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED ISR_Level level; struct timespec offset; /* assume uptime checked by caller */ offset.tv_sec = 0; 10f8f3: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED offset.tv_nsec = 0; 10f8fa: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED _ISR_Disable( level ); 10f901: 9c pushf <== NOT EXECUTED 10f902: fa cli <== NOT EXECUTED 10f903: 5b pop %ebx <== NOT EXECUTED *uptime = _TOD_Uptime; 10f904: a1 38 f8 11 00 mov 0x11f838,%eax <== NOT EXECUTED 10f909: 8b 15 3c f8 11 00 mov 0x11f83c,%edx <== NOT EXECUTED 10f90f: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10f911: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED if ( _Watchdog_Nanoseconds_since_tick_handler ) 10f914: a1 88 f9 11 00 mov 0x11f988,%eax <== NOT EXECUTED 10f919: 85 c0 test %eax,%eax <== NOT EXECUTED 10f91b: 74 05 je 10f922 <_TOD_Get_uptime+0x3a> <== NOT EXECUTED offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)(); 10f91d: ff d0 call *%eax <== NOT EXECUTED 10f91f: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED _ISR_Enable( level ); 10f922: 53 push %ebx <== NOT EXECUTED 10f923: 9d popf <== NOT EXECUTED _Timespec_Add_to( uptime, &offset ); 10f924: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f927: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10f92a: 50 push %eax <== NOT EXECUTED 10f92b: 56 push %esi <== NOT EXECUTED 10f92c: e8 4b d6 ff ff call 10cf7c <_Timespec_Add_to> <== NOT EXECUTED 10f931: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10f934: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f937: 5b pop %ebx <== NOT EXECUTED 10f938: 5e pop %esi <== NOT EXECUTED 10f939: c9 leave <== NOT EXECUTED 10f93a: c3 ret <== NOT EXECUTED 0010b2f0 <_TOD_Handler_initialization>: */ void _TOD_Handler_initialization( uint32_t microseconds_per_tick ) { 10b2f0: 55 push %ebp <== NOT EXECUTED 10b2f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED _TOD_Microseconds_per_tick = microseconds_per_tick; 10b2f3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b2f6: a3 80 f9 11 00 mov %eax,0x11f980 <== NOT EXECUTED /* POSIX format TOD (timespec) */ _TOD_Now.tv_sec = TOD_SECONDS_1970_THROUGH_1988; 10b2fb: c7 05 4c f8 11 00 00 movl $0x21dae500,0x11f84c <== NOT EXECUTED 10b302: e5 da 21 <== NOT EXECUTED _TOD_Now.tv_nsec = 0; 10b305: c7 05 50 f8 11 00 00 movl $0x0,0x11f850 <== NOT EXECUTED 10b30c: 00 00 00 <== NOT EXECUTED /* Uptime (timespec) */ _TOD_Uptime.tv_sec = 0; 10b30f: c7 05 38 f8 11 00 00 movl $0x0,0x11f838 <== NOT EXECUTED 10b316: 00 00 00 <== NOT EXECUTED _TOD_Uptime.tv_nsec = 0; 10b319: c7 05 3c f8 11 00 00 movl $0x0,0x11f83c <== NOT EXECUTED 10b320: 00 00 00 <== NOT EXECUTED /* TOD has not been set */ _TOD_Is_set = FALSE; 10b323: c6 05 cc f7 11 00 00 movb $0x0,0x11f7cc <== NOT EXECUTED _TOD_Activate(); } 10b32a: c9 leave <== NOT EXECUTED 10b32b: c3 ret <== NOT EXECUTED 0010c62c <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 10c62c: 55 push %ebp <== NOT EXECUTED 10c62d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c62f: 53 push %ebx <== NOT EXECUTED 10c630: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10c633: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10c636: a1 d8 b7 12 00 mov 0x12b7d8,%eax <== NOT EXECUTED 10c63b: 40 inc %eax <== NOT EXECUTED 10c63c: a3 d8 b7 12 00 mov %eax,0x12b7d8 <== NOT EXECUTED _Thread_Disable_dispatch(); _TOD_Deactivate(); if ( time->tv_sec < _TOD_Seconds_since_epoch ) 10c641: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10c643: a1 6c b8 12 00 mov 0x12b86c,%eax <== NOT EXECUTED 10c648: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10c64a: 7c 34 jl 10c680 <_TOD_Set+0x54> <== NOT EXECUTED */ bool _Protected_heap_Free( Heap_Control *the_heap, void *start_address ); 10c64c: 51 push %ecx <== NOT EXECUTED 10c64d: 29 c2 sub %eax,%edx <== NOT EXECUTED 10c64f: 52 push %edx <== NOT EXECUTED 10c650: 6a 00 push $0x0 <== NOT EXECUTED 10c652: 68 b0 b8 12 00 push $0x12b8b0 <== NOT EXECUTED 10c657: e8 a8 23 00 00 call 10ea04 <_Watchdog_Adjust> <== NOT EXECUTED 10c65c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else _Watchdog_Adjust_seconds( WATCHDOG_FORWARD, time->tv_sec - _TOD_Seconds_since_epoch ); /* POSIX format TOD (timespec) */ _TOD_Now = *time; 10c65f: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10c661: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10c664: a3 70 b8 12 00 mov %eax,0x12b870 <== NOT EXECUTED 10c669: 89 15 6c b8 12 00 mov %edx,0x12b86c <== NOT EXECUTED _TOD_Is_set = TRUE; 10c66f: c6 05 ec b7 12 00 01 movb $0x1,0x12b7ec <== NOT EXECUTED _TOD_Activate(); _Thread_Enable_dispatch(); } 10c676: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c679: c9 leave <== NOT EXECUTED _TOD_Now = *time; _TOD_Is_set = TRUE; _TOD_Activate(); _Thread_Enable_dispatch(); 10c67a: e9 99 11 00 00 jmp 10d818 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c67f: 90 nop <== NOT EXECUTED 10c680: 51 push %ecx <== NOT EXECUTED 10c681: 29 d0 sub %edx,%eax <== NOT EXECUTED 10c683: 50 push %eax <== NOT EXECUTED 10c684: 6a 01 push $0x1 <== NOT EXECUTED 10c686: 68 b0 b8 12 00 push $0x12b8b0 <== NOT EXECUTED 10c68b: e8 74 23 00 00 call 10ea04 <_Watchdog_Adjust> <== NOT EXECUTED 10c690: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c693: eb ca jmp 10c65f <_TOD_Set+0x33> <== NOT EXECUTED 0010b32c <_TOD_Tickle_ticks>: * * Output parameters: NONE */ void _TOD_Tickle_ticks( void ) { 10b32c: 55 push %ebp <== NOT EXECUTED 10b32d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b32f: 53 push %ebx <== NOT EXECUTED 10b330: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED struct timespec tick; uint32_t seconds; /* Convert the tick quantum to a timespec */ tick.tv_nsec = _TOD_Microseconds_per_tick * 1000; 10b333: a1 80 f9 11 00 mov 0x11f980,%eax <== NOT EXECUTED 10b338: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10b33b: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10b33e: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10b341: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 10b344: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED tick.tv_sec = 0; 10b347: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED /* Update the counter of ticks since boot */ _Watchdog_Ticks_since_boot += 1; 10b34e: a1 24 f9 11 00 mov 0x11f924,%eax <== NOT EXECUTED 10b353: 40 inc %eax <== NOT EXECUTED 10b354: a3 24 f9 11 00 mov %eax,0x11f924 <== NOT EXECUTED /* Update the timespec format uptime */ (void) _Timespec_Add_to( &_TOD_Uptime, &tick ); 10b359: 8d 5d f4 lea -0xc(%ebp),%ebx <== NOT EXECUTED 10b35c: 53 push %ebx <== NOT EXECUTED 10b35d: 68 38 f8 11 00 push $0x11f838 <== NOT EXECUTED 10b362: e8 15 1c 00 00 call 10cf7c <_Timespec_Add_to> <== NOT EXECUTED /* we do not care how much the uptime changed */ /* Update the timespec format TOD */ seconds = _Timespec_Add_to( &_TOD_Now, &tick ); 10b367: 58 pop %eax <== NOT EXECUTED 10b368: 5a pop %edx <== NOT EXECUTED 10b369: 53 push %ebx <== NOT EXECUTED 10b36a: 68 4c f8 11 00 push $0x11f84c <== NOT EXECUTED 10b36f: e8 08 1c 00 00 call 10cf7c <_Timespec_Add_to> <== NOT EXECUTED 10b374: 89 c3 mov %eax,%ebx <== NOT EXECUTED while ( seconds ) { 10b376: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b379: 85 c0 test %eax,%eax <== NOT EXECUTED 10b37b: 74 16 je 10b393 <_TOD_Tickle_ticks+0x67> <== NOT EXECUTED 10b37d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 10b380: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b383: 68 90 f8 11 00 push $0x11f890 <== NOT EXECUTED 10b388: e8 6b 20 00 00 call 10d3f8 <_Watchdog_Tickle> <== NOT EXECUTED 10b38d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b390: 4b dec %ebx <== NOT EXECUTED 10b391: 75 ed jne 10b380 <_TOD_Tickle_ticks+0x54> <== NOT EXECUTED _Watchdog_Tickle_seconds(); seconds--; } } 10b393: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b396: c9 leave <== NOT EXECUTED 10b397: c3 ret <== NOT EXECUTED 0010ac20 <_TOD_To_seconds>: */ uint32_t _TOD_To_seconds( rtems_time_of_day *the_tod ) { 10ac20: 55 push %ebp <== NOT EXECUTED 10ac21: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac23: 57 push %edi <== NOT EXECUTED 10ac24: 56 push %esi <== NOT EXECUTED 10ac25: 53 push %ebx <== NOT EXECUTED 10ac26: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED uint32_t time; uint32_t year_mod_4; time = the_tod->day - 1; 10ac29: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10ac2c: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED year_mod_4 = the_tod->year & 3; 10ac2f: 8b 13 mov (%ebx),%edx <== NOT EXECUTED if ( year_mod_4 == 0 ) 10ac31: 89 d6 mov %edx,%esi <== NOT EXECUTED 10ac33: 83 e6 03 and $0x3,%esi <== NOT EXECUTED 10ac36: 74 68 je 10aca0 <_TOD_To_seconds+0x80> <== NOT EXECUTED time += _TOD_Days_to_date[ 1 ][ the_tod->month ]; else time += _TOD_Days_to_date[ 0 ][ the_tod->month ]; 10ac38: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10ac3b: 0f b7 84 00 e0 c6 11 movzwl 0x11c6e0(%eax,%eax,1),%eax <== NOT EXECUTED 10ac42: 00 <== NOT EXECUTED 10ac43: 8d 3c 08 lea (%eax,%ecx,1),%edi <== NOT EXECUTED time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) * 10ac46: 0f b7 8c 36 14 c7 11 movzwl 0x11c714(%esi,%esi,1),%ecx <== NOT EXECUTED 10ac4d: 00 <== NOT EXECUTED 10ac4e: 81 ea c4 07 00 00 sub $0x7c4,%edx <== NOT EXECUTED 10ac54: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED 10ac57: 8d 04 d2 lea (%edx,%edx,8),%eax <== NOT EXECUTED 10ac5a: 8d 04 c2 lea (%edx,%eax,8),%eax <== NOT EXECUTED 10ac5d: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10ac60: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 10ac63: 01 c1 add %eax,%ecx <== NOT EXECUTED ( (TOD_DAYS_PER_YEAR * 4) + 1); time += _TOD_Days_since_last_leap_year[ year_mod_4 ]; 10ac65: 01 f9 add %edi,%ecx <== NOT EXECUTED time *= TOD_SECONDS_PER_DAY; 10ac67: 8d 14 89 lea (%ecx,%ecx,4),%edx <== NOT EXECUTED 10ac6a: 8d 14 91 lea (%ecx,%edx,4),%edx <== NOT EXECUTED 10ac6d: 8d 14 d1 lea (%ecx,%edx,8),%edx <== NOT EXECUTED 10ac70: c1 e2 02 shl $0x2,%edx <== NOT EXECUTED 10ac73: 29 ca sub %ecx,%edx <== NOT EXECUTED 10ac75: c1 e2 07 shl $0x7,%edx <== NOT EXECUTED time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute) 10ac78: 8b 4b 14 mov 0x14(%ebx),%ecx <== NOT EXECUTED * TOD_SECONDS_PER_MINUTE; time += the_tod->second; 10ac7b: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10ac7e: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10ac81: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10ac84: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10ac87: 03 43 10 add 0x10(%ebx),%eax <== NOT EXECUTED 10ac8a: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10ac8d: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10ac90: 8d 84 81 00 e5 da 21 lea 0x21dae500(%ecx,%eax,4),%eax <== NOT EXECUTED 10ac97: 01 d0 add %edx,%eax <== NOT EXECUTED time += TOD_SECONDS_1970_THROUGH_1988; return( time ); } 10ac99: 5b pop %ebx <== NOT EXECUTED 10ac9a: 5e pop %esi <== NOT EXECUTED 10ac9b: 5f pop %edi <== NOT EXECUTED 10ac9c: c9 leave <== NOT EXECUTED 10ac9d: c3 ret <== NOT EXECUTED 10ac9e: 66 90 xchg %ax,%ax <== NOT EXECUTED time = the_tod->day - 1; year_mod_4 = the_tod->year & 3; if ( year_mod_4 == 0 ) time += _TOD_Days_to_date[ 1 ][ the_tod->month ]; 10aca0: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10aca3: 0f b7 84 00 fa c6 11 movzwl 0x11c6fa(%eax,%eax,1),%eax <== NOT EXECUTED 10acaa: 00 <== NOT EXECUTED 10acab: 8d 3c 08 lea (%eax,%ecx,1),%edi <== NOT EXECUTED 10acae: eb 96 jmp 10ac46 <_TOD_To_seconds+0x26> <== NOT EXECUTED 0010acb0 <_TOD_Validate>: */ bool _TOD_Validate( rtems_time_of_day *the_tod ) { 10acb0: 55 push %ebp <== NOT EXECUTED 10acb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10acb3: 53 push %ebx <== NOT EXECUTED 10acb4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10acb7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED uint32_t days_in_month; if ((!the_tod) || 10acba: 85 db test %ebx,%ebx <== NOT EXECUTED 10acbc: 74 56 je 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED 10acbe: b8 40 42 0f 00 mov $0xf4240,%eax <== NOT EXECUTED 10acc3: 31 d2 xor %edx,%edx <== NOT EXECUTED 10acc5: f7 35 a0 b9 12 00 divl 0x12b9a0 <== NOT EXECUTED 10accb: 39 43 18 cmp %eax,0x18(%ebx) <== NOT EXECUTED 10acce: 73 44 jae 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED 10acd0: 83 7b 14 3b cmpl $0x3b,0x14(%ebx) <== NOT EXECUTED 10acd4: 77 3e ja 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED 10acd6: 83 7b 10 3b cmpl $0x3b,0x10(%ebx) <== NOT EXECUTED 10acda: 77 38 ja 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED 10acdc: 83 7b 0c 17 cmpl $0x17,0xc(%ebx) <== NOT EXECUTED 10ace0: 77 32 ja 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED 10ace2: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10ace5: 85 c0 test %eax,%eax <== NOT EXECUTED 10ace7: 74 2b je 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED 10ace9: 83 f8 0c cmp $0xc,%eax <== NOT EXECUTED 10acec: 77 26 ja 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED 10acee: 8b 0b mov (%ebx),%ecx <== NOT EXECUTED 10acf0: 81 f9 c3 07 00 00 cmp $0x7c3,%ecx <== NOT EXECUTED 10acf6: 76 1c jbe 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED 10acf8: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10acfb: 85 d2 test %edx,%edx <== NOT EXECUTED 10acfd: 74 15 je 10ad14 <_TOD_Validate+0x64> <== NOT EXECUTED (the_tod->month > TOD_MONTHS_PER_YEAR) || (the_tod->year < TOD_BASE_YEAR) || (the_tod->day == 0) ) return false; if ( (the_tod->year % 4) == 0 ) 10acff: 83 e1 03 and $0x3,%ecx <== NOT EXECUTED 10ad02: 75 16 jne 10ad1a <_TOD_Validate+0x6a> <== NOT EXECUTED days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 10ad04: 8b 04 85 54 c7 11 00 mov 0x11c754(,%eax,4),%eax <== NOT EXECUTED else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10ad0b: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10ad0d: 0f 93 c0 setae %al <== NOT EXECUTED 10ad10: eb 04 jmp 10ad16 <_TOD_Validate+0x66> <== NOT EXECUTED 10ad12: 66 90 xchg %ax,%ax <== NOT EXECUTED 10ad14: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( the_tod->day > days_in_month ) return false; return true; } 10ad16: 5a pop %edx <== NOT EXECUTED 10ad17: 5b pop %ebx <== NOT EXECUTED 10ad18: c9 leave <== NOT EXECUTED 10ad19: c3 ret <== NOT EXECUTED return false; if ( (the_tod->year % 4) == 0 ) days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10ad1a: 8b 04 85 20 c7 11 00 mov 0x11c720(,%eax,4),%eax <== NOT EXECUTED 10ad21: eb e8 jmp 10ad0b <_TOD_Validate+0x5b> <== NOT EXECUTED 0010be70 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10be70: 55 push %ebp <== NOT EXECUTED 10be71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10be73: 57 push %edi <== NOT EXECUTED 10be74: 56 push %esi <== NOT EXECUTED 10be75: 53 push %ebx <== NOT EXECUTED 10be76: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10be79: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10be7c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10be7f: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10be82: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED */ /* * Save original state */ original_state = the_thread->current_state; 10be85: 8b 7b 10 mov 0x10(%ebx),%edi <== NOT EXECUTED /* * Set a transient state for the thread so it is pulled off the Ready chains. * This will prevent it from being scheduled no matter what happens in an * ISR. */ _Thread_Set_transient( the_thread ); 10be88: 53 push %ebx <== NOT EXECUTED 10be89: e8 4a 0e 00 00 call 10ccd8 <_Thread_Set_transient> <== NOT EXECUTED /* * Do not bother recomputing all the priority related information if * we are not REALLY changing priority. */ if ( the_thread->current_priority != new_priority ) 10be8e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10be91: 39 73 14 cmp %esi,0x14(%ebx) <== NOT EXECUTED 10be94: 74 0d je 10bea3 <_Thread_Change_priority+0x33> <== NOT EXECUTED _Thread_Set_priority( the_thread, new_priority ); 10be96: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10be99: 56 push %esi <== NOT EXECUTED 10be9a: 53 push %ebx <== NOT EXECUTED 10be9b: e8 f4 0c 00 00 call 10cb94 <_Thread_Set_priority> <== NOT EXECUTED 10bea0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _ISR_Disable( level ); 10bea3: 9c pushf <== NOT EXECUTED 10bea4: fa cli <== NOT EXECUTED 10bea5: 5e pop %esi <== NOT EXECUTED /* * If the thread has more than STATES_TRANSIENT set, then it is blocked, * If it is blocked on a thread queue, then we need to requeue it. */ state = the_thread->current_state; 10bea6: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED if ( state != STATES_TRANSIENT ) { 10bea9: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10beac: 74 3a je 10bee8 <_Thread_Change_priority+0x78> <== NOT EXECUTED /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10beae: 83 e7 04 and $0x4,%edi <== NOT EXECUTED 10beb1: 75 08 jne 10bebb <_Thread_Change_priority+0x4b> <== NOT EXECUTED the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10beb3: 89 d0 mov %edx,%eax <== NOT EXECUTED 10beb5: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 10beb8: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10bebb: 56 push %esi <== NOT EXECUTED 10bebc: 9d popf <== NOT EXECUTED if ( _States_Is_waiting_on_thread_queue( state ) ) { 10bebd: 81 e2 e0 be 03 00 and $0x3bee0,%edx <== NOT EXECUTED 10bec3: 75 0b jne 10bed0 <_Thread_Change_priority+0x60> <== NOT EXECUTED if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10bec5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bec8: 5b pop %ebx <== NOT EXECUTED 10bec9: 5e pop %esi <== NOT EXECUTED 10beca: 5f pop %edi <== NOT EXECUTED 10becb: c9 leave <== NOT EXECUTED 10becc: c3 ret <== NOT EXECUTED 10becd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); if ( _States_Is_waiting_on_thread_queue( state ) ) { _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10bed0: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 10bed3: 8b 43 44 mov 0x44(%ebx),%eax <== NOT EXECUTED 10bed6: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10bed9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bedc: 5b pop %ebx <== NOT EXECUTED 10bedd: 5e pop %esi <== NOT EXECUTED 10bede: 5f pop %edi <== NOT EXECUTED 10bedf: c9 leave <== NOT EXECUTED /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); _ISR_Enable( level ); if ( _States_Is_waiting_on_thread_queue( state ) ) { _Thread_queue_Requeue( the_thread->Wait.queue, the_thread ); 10bee0: e9 1b 0c 00 00 jmp 10cb00 <_Thread_queue_Requeue> <== NOT EXECUTED 10bee5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10bee8: 83 e7 04 and $0x4,%edi <== NOT EXECUTED 10beeb: 75 41 jne 10bf2e <_Thread_Change_priority+0xbe> <== NOT EXECUTED * Interrupts are STILL disabled. * We now know the thread will be in the READY state when we remove * the TRANSIENT state. So we have to place it on the appropriate * Ready Queue with interrupts off. */ the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10beed: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in 10bef4: 8b 93 90 00 00 00 mov 0x90(%ebx),%edx <== NOT EXECUTED 10befa: 66 8b 83 96 00 00 00 mov 0x96(%ebx),%ax <== NOT EXECUTED 10bf01: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10bf04: 66 a1 70 f8 11 00 mov 0x11f870,%ax <== NOT EXECUTED 10bf0a: 0b 83 94 00 00 00 or 0x94(%ebx),%eax <== NOT EXECUTED 10bf10: 66 a3 70 f8 11 00 mov %ax,0x11f870 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); if ( prepend_it ) 10bf16: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10bf1a: 74 70 je 10bf8c <_Thread_Change_priority+0x11c> <== NOT EXECUTED size_t size ); /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the 10bf1c: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax <== NOT EXECUTED 10bf22: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED 10bf25: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10bf27: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10bf29: 89 13 mov %edx,(%ebx) <== NOT EXECUTED 10bf2b: 89 5a 04 mov %ebx,0x4(%edx) <== NOT EXECUTED _Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node ); else _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node ); } _ISR_Flash( level ); 10bf2e: 56 push %esi <== NOT EXECUTED 10bf2f: 9d popf <== NOT EXECUTED 10bf30: fa cli <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10bf31: 66 8b 0d 70 f8 11 00 mov 0x11f870,%cx <== NOT EXECUTED 10bf38: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bf3a: 89 d0 mov %edx,%eax <== NOT EXECUTED 10bf3c: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10bf40: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10bf43: 66 8b 8c 00 00 f9 11 mov 0x11f900(%eax,%eax,1),%cx <== NOT EXECUTED 10bf4a: 00 <== NOT EXECUTED 10bf4b: 66 0f bc d1 bsf %cx,%dx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10bf4f: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10bf52: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10bf55: 01 d0 add %edx,%eax <== NOT EXECUTED 10bf57: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10bf5a: 8b 15 80 f7 11 00 mov 0x11f780,%edx <== NOT EXECUTED 10bf60: 8b 04 82 mov (%edx,%eax,4),%eax <== NOT EXECUTED 10bf63: a3 48 f8 11 00 mov %eax,0x11f848 <== NOT EXECUTED void *starting_address, size_t size ); /** * This function attempts to allocate a block of @a size bytes from 10bf68: 8b 15 7c f8 11 00 mov 0x11f87c,%edx <== NOT EXECUTED * We altered the set of thread priorities. So let's figure out * who is the heir and if we need to switch to them. */ _Thread_Calculate_heir(); if ( !_Thread_Is_executing_also_the_heir() && 10bf6e: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10bf70: 74 0d je 10bf7f <_Thread_Change_priority+0x10f> <== NOT EXECUTED 10bf72: 80 7a 76 00 cmpb $0x0,0x76(%edx) <== NOT EXECUTED 10bf76: 74 07 je 10bf7f <_Thread_Change_priority+0x10f> <== NOT EXECUTED _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; 10bf78: c6 05 8c f8 11 00 01 movb $0x1,0x11f88c <== NOT EXECUTED _ISR_Enable( level ); 10bf7f: 56 push %esi <== NOT EXECUTED 10bf80: 9d popf <== NOT EXECUTED } 10bf81: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bf84: 5b pop %ebx <== NOT EXECUTED 10bf85: 5e pop %esi <== NOT EXECUTED 10bf86: 5f pop %edi <== NOT EXECUTED 10bf87: c9 leave <== NOT EXECUTED 10bf88: c3 ret <== NOT EXECUTED 10bf89: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); if ( prepend_it ) _Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node ); else _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node ); 10bf8c: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax <== NOT EXECUTED 10bf92: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10bf95: 89 13 mov %edx,(%ebx) <== NOT EXECUTED 10bf97: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10bf9a: 89 58 08 mov %ebx,0x8(%eax) <== NOT EXECUTED 10bf9d: 89 1a mov %ebx,(%edx) <== NOT EXECUTED 10bf9f: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 10bfa2: eb 8a jmp 10bf2e <_Thread_Change_priority+0xbe> <== NOT EXECUTED 0010bfa4 <_Thread_Clear_state>: void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 10bfa4: 55 push %ebp <== NOT EXECUTED 10bfa5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bfa7: 53 push %ebx <== NOT EXECUTED 10bfa8: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10bfab: 9c pushf <== NOT EXECUTED 10bfac: fa cli <== NOT EXECUTED 10bfad: 5b pop %ebx <== NOT EXECUTED current_state = the_thread->current_state; 10bfae: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED if ( current_state & state ) { 10bfb1: 85 55 0c test %edx,0xc(%ebp) <== NOT EXECUTED 10bfb4: 74 72 je 10c028 <_Thread_Clear_state+0x84> <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10bfb6: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10bfb9: f7 d0 not %eax <== NOT EXECUTED 10bfbb: 21 d0 and %edx,%eax <== NOT EXECUTED current_state = 10bfbd: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED the_thread->current_state = _States_Clear( state, current_state ); if ( _States_Is_ready( current_state ) ) { 10bfc0: 85 c0 test %eax,%eax <== NOT EXECUTED 10bfc2: 75 64 jne 10c028 <_Thread_Clear_state+0x84> <== NOT EXECUTED * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in 10bfc4: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10bfca: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10bfd1: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10bfd4: 66 a1 70 f8 11 00 mov 0x11f870,%ax <== NOT EXECUTED 10bfda: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10bfe0: 66 a3 70 f8 11 00 mov %ax,0x11f870 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10bfe6: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10bfec: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10bfef: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10bff1: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10bff4: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10bff7: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10bff9: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10bffc: 53 push %ebx <== NOT EXECUTED 10bffd: 9d popf <== NOT EXECUTED 10bffe: fa cli <== NOT EXECUTED * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10bfff: 8b 51 14 mov 0x14(%ecx),%edx <== NOT EXECUTED 10c002: a1 48 f8 11 00 mov 0x11f848,%eax <== NOT EXECUTED 10c007: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10c00a: 73 1c jae 10c028 <_Thread_Clear_state+0x84> <== NOT EXECUTED _Thread_Heir = the_thread; 10c00c: 89 0d 48 f8 11 00 mov %ecx,0x11f848 <== NOT EXECUTED if ( _Thread_Executing->is_preemptible || 10c012: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED 10c017: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10c01b: 75 04 jne 10c021 <_Thread_Clear_state+0x7d> <== NOT EXECUTED 10c01d: 85 d2 test %edx,%edx <== NOT EXECUTED 10c01f: 75 07 jne 10c028 <_Thread_Clear_state+0x84> <== NOT EXECUTED the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10c021: c6 05 8c f8 11 00 01 movb $0x1,0x11f88c <== NOT EXECUTED } } } _ISR_Enable( level ); 10c028: 53 push %ebx <== NOT EXECUTED 10c029: 9d popf <== NOT EXECUTED } 10c02a: 5b pop %ebx <== NOT EXECUTED 10c02b: c9 leave <== NOT EXECUTED 10c02c: c3 ret <== NOT EXECUTED 0010c030 <_Thread_Close>: void _Thread_Close( Objects_Information *information, Thread_Control *the_thread ) { 10c030: 55 push %ebp <== NOT EXECUTED 10c031: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c033: 56 push %esi <== NOT EXECUTED 10c034: 53 push %ebx <== NOT EXECUTED 10c035: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10c038: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10c03b: 0f b7 56 08 movzwl 0x8(%esi),%edx <== NOT EXECUTED 10c03f: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10c042: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) <== NOT EXECUTED 10c049: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10c04e: 48 dec %eax <== NOT EXECUTED 10c04f: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED * disappear and set a transient state on it. So we temporarily * unnest dispatching. */ _Thread_Unnest_dispatch(); _User_extensions_Thread_delete( the_thread ); 10c054: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c057: 56 push %esi <== NOT EXECUTED 10c058: e8 3f 11 00 00 call 10d19c <_User_extensions_Thread_delete> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10c05d: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10c062: 40 inc %eax <== NOT EXECUTED 10c063: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED /* * Now we are in a dispatching critical section again and we * can take the thread OUT of the published set. It is invalid * to use this thread's Id OR name after this call. */ _Objects_Close( information, &the_thread->Object ); 10c068: 59 pop %ecx <== NOT EXECUTED 10c069: 58 pop %eax <== NOT EXECUTED 10c06a: 56 push %esi <== NOT EXECUTED 10c06b: 53 push %ebx <== NOT EXECUTED 10c06c: e8 23 f6 ff ff call 10b694 <_Objects_Close> <== NOT EXECUTED /* * By setting the dormant state, the thread will not be considered * for scheduling when we remove any blocking states. */ _Thread_Set_state( the_thread, STATES_DORMANT ); 10c071: 58 pop %eax <== NOT EXECUTED 10c072: 5a pop %edx <== NOT EXECUTED 10c073: 6a 01 push $0x1 <== NOT EXECUTED 10c075: 56 push %esi <== NOT EXECUTED 10c076: e8 85 0b 00 00 call 10cc00 <_Thread_Set_state> <== NOT EXECUTED if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 10c07b: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10c07e: e8 a5 09 00 00 call 10ca28 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 10c083: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c086: 84 c0 test %al,%al <== NOT EXECUTED 10c088: 75 06 jne 10c090 <_Thread_Close+0x60> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 10c08a: 83 7e 50 02 cmpl $0x2,0x50(%esi) <== NOT EXECUTED 10c08e: 74 68 je 10c0f8 <_Thread_Close+0xc8> <== NOT EXECUTED /* * The thread might have been FP. So deal with that. */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( _Thread_Is_allocated_fp( the_thread ) ) 10c090: 3b 35 40 f8 11 00 cmp 0x11f840,%esi <== NOT EXECUTED 10c096: 74 74 je 10c10c <_Thread_Close+0xdc> <== NOT EXECUTED _Thread_Deallocate_fp(); #endif the_thread->fp_context = NULL; 10c098: c7 86 ec 00 00 00 00 movl $0x0,0xec(%esi) <== NOT EXECUTED 10c09f: 00 00 00 <== NOT EXECUTED if ( the_thread->Start.fp_context ) 10c0a2: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED 10c0a8: 85 c0 test %eax,%eax <== NOT EXECUTED 10c0aa: 74 0c je 10c0b8 <_Thread_Close+0x88> <== NOT EXECUTED (void) _Workspace_Free( the_thread->Start.fp_context ); 10c0ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0af: 50 push %eax <== NOT EXECUTED 10c0b0: e8 b3 13 00 00 call 10d468 <_Workspace_Free> <== NOT EXECUTED 10c0b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Free the rest of the memory associated with this task * and set the associated pointers to NULL for safety. */ _Thread_Stack_Free( the_thread ); 10c0b8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0bb: 56 push %esi <== NOT EXECUTED 10c0bc: e8 ef 0c 00 00 call 10cdb0 <_Thread_Stack_Free> <== NOT EXECUTED the_thread->Start.stack = NULL; 10c0c1: c7 86 d0 00 00 00 00 movl $0x0,0xd0(%esi) <== NOT EXECUTED 10c0c8: 00 00 00 <== NOT EXECUTED if ( the_thread->extensions ) 10c0cb: 8b 86 00 01 00 00 mov 0x100(%esi),%eax <== NOT EXECUTED 10c0d1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0d4: 85 c0 test %eax,%eax <== NOT EXECUTED 10c0d6: 74 0c je 10c0e4 <_Thread_Close+0xb4> <== NOT EXECUTED (void) _Workspace_Free( the_thread->extensions ); 10c0d8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0db: 50 push %eax <== NOT EXECUTED 10c0dc: e8 87 13 00 00 call 10d468 <_Workspace_Free> <== NOT EXECUTED 10c0e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_thread->extensions = NULL; 10c0e4: c7 86 00 01 00 00 00 movl $0x0,0x100(%esi) <== NOT EXECUTED 10c0eb: 00 00 00 <== NOT EXECUTED } 10c0ee: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c0f1: 5b pop %ebx <== NOT EXECUTED 10c0f2: 5e pop %esi <== NOT EXECUTED 10c0f3: c9 leave <== NOT EXECUTED 10c0f4: c3 ret <== NOT EXECUTED 10c0f5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ _Thread_Set_state( the_thread, STATES_DORMANT ); if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { if ( _Watchdog_Is_active( &the_thread->Timer ) ) (void) _Watchdog_Remove( &the_thread->Timer ); 10c0f8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c0fb: 8d 46 48 lea 0x48(%esi),%eax <== NOT EXECUTED 10c0fe: 50 push %eax <== NOT EXECUTED 10c0ff: e8 88 12 00 00 call 10d38c <_Watchdog_Remove> <== NOT EXECUTED 10c104: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c107: eb 87 jmp 10c090 <_Thread_Close+0x60> <== NOT EXECUTED 10c109: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * @param[in] size is the new size * * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( 10c10c: c7 05 40 f8 11 00 00 movl $0x0,0x11f840 <== NOT EXECUTED 10c113: 00 00 00 <== NOT EXECUTED 10c116: eb 80 jmp 10c098 <_Thread_Close+0x68> <== NOT EXECUTED 0010c118 <_Thread_Create_idle>: * * _Thread_Create_idle */ void _Thread_Create_idle( void ) { 10c118: 55 push %ebp <== NOT EXECUTED 10c119: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c11b: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10c11e: 68 40 f9 11 00 push $0x11f940 <== NOT EXECUTED 10c123: e8 ec f4 ff ff call 10b614 <_Objects_Allocate> <== NOT EXECUTED /* * 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(); 10c128: a3 8c f9 11 00 mov %eax,0x11f98c <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10c12d: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10c132: 40 inc %eax <== NOT EXECUTED 10c133: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED * that when _Thread_Initialize unnests dispatch that we do not * do anything stupid. */ _Thread_Disable_dispatch(); _Thread_Initialize( 10c138: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10c13d: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED 10c140: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c143: 68 f8 90 11 00 push $0x1190f8 <== NOT EXECUTED 10c148: 6a 00 push $0x0 <== NOT EXECUTED 10c14a: 6a 00 push $0x0 <== NOT EXECUTED 10c14c: 6a 00 push $0x0 <== NOT EXECUTED 10c14e: 6a 01 push $0x1 <== NOT EXECUTED 10c150: 0f b6 05 d4 b1 11 00 movzbl 0x11b1d4,%eax <== NOT EXECUTED 10c157: 50 push %eax <== NOT EXECUTED 10c158: 6a 00 push $0x0 <== NOT EXECUTED 10c15a: a1 d0 b1 11 00 mov 0x11b1d0,%eax <== NOT EXECUTED 10c15f: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10c161: 73 02 jae 10c165 <_Thread_Create_idle+0x4d> <== NOT EXECUTED 10c163: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c165: 50 push %eax <== NOT EXECUTED 10c166: 6a 00 push $0x0 <== NOT EXECUTED 10c168: ff 35 8c f9 11 00 pushl 0x11f98c <== NOT EXECUTED 10c16e: 68 40 f9 11 00 push $0x11f940 <== NOT EXECUTED 10c173: e8 78 02 00 00 call 10c3f0 <_Thread_Initialize> <== NOT EXECUTED 10c178: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10c17d: 48 dec %eax <== NOT EXECUTED 10c17e: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 10c183: 8b 15 8c f9 11 00 mov 0x11f98c,%edx <== NOT EXECUTED 10c189: 89 15 7c f8 11 00 mov %edx,0x11f87c <== NOT EXECUTED 10c18f: 89 15 48 f8 11 00 mov %edx,0x11f848 <== NOT EXECUTED _Thread_Executing = _Thread_Idle; _Thread_Start( 10c195: 83 c4 24 add $0x24,%esp <== NOT EXECUTED 10c198: 6a 00 push $0x0 <== NOT EXECUTED 10c19a: 6a 00 push $0x0 <== NOT EXECUTED 10c19c: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10c1a1: ff 70 14 pushl 0x14(%eax) <== NOT EXECUTED 10c1a4: 6a 00 push $0x0 <== NOT EXECUTED 10c1a6: 52 push %edx <== NOT EXECUTED 10c1a7: e8 9c 0c 00 00 call 10ce48 <_Thread_Start> <== NOT EXECUTED 10c1ac: 83 c4 20 add $0x20,%esp <== NOT EXECUTED _Configuration_Table->idle_task, NULL, 0 ); } 10c1af: c9 leave <== NOT EXECUTED 10c1b0: c3 ret <== NOT EXECUTED 0010c1b4 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 10c1b4: 55 push %ebp <== NOT EXECUTED 10c1b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c1b7: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c1ba: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10c1bd: 50 push %eax <== NOT EXECUTED 10c1be: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c1c1: e8 aa 01 00 00 call 10c370 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10c1c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c1c9: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10c1cc: 85 d2 test %edx,%edx <== NOT EXECUTED 10c1ce: 75 1c jne 10c1ec <_Thread_Delay_ended+0x38> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10c1d0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c1d3: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10c1d8: 50 push %eax <== NOT EXECUTED 10c1d9: e8 c6 fd ff ff call 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 10c1de: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10c1e3: 48 dec %eax <== NOT EXECUTED 10c1e4: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED 10c1e9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_LOCAL: _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; } } 10c1ec: c9 leave <== NOT EXECUTED 10c1ed: c3 ret <== NOT EXECUTED 0010c1f0 <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10c1f0: 55 push %ebp <== NOT EXECUTED 10c1f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c1f3: 57 push %edi <== NOT EXECUTED 10c1f4: 56 push %esi <== NOT EXECUTED 10c1f5: 53 push %ebx <== NOT EXECUTED 10c1f6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10c1f9: 8b 35 7c f8 11 00 mov 0x11f87c,%esi <== NOT EXECUTED _ISR_Disable( level ); 10c1ff: 9c pushf <== NOT EXECUTED 10c200: fa cli <== NOT EXECUTED 10c201: 5a pop %edx <== NOT EXECUTED while ( _Context_Switch_necessary == TRUE ) { 10c202: a0 8c f8 11 00 mov 0x11f88c,%al <== NOT EXECUTED 10c207: 84 c0 test %al,%al <== NOT EXECUTED 10c209: 0f 84 11 01 00 00 je 10c320 <_Thread_Dispatch+0x130> <== NOT EXECUTED 10c20f: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10c212: e9 d2 00 00 00 jmp 10c2e9 <_Thread_Dispatch+0xf9> <== NOT EXECUTED 10c217: 90 nop <== NOT EXECUTED executing->rtems_ada_self = rtems_ada_self; rtems_ada_self = heir->rtems_ada_self; #endif if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) heir->cpu_time_budget = _Thread_Ticks_per_timeslice; _ISR_Enable( level ); 10c218: 52 push %edx <== NOT EXECUTED 10c219: 9d popf <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec uptime, ran; _TOD_Get_uptime( &uptime ); 10c21a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c21d: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10c220: 50 push %eax <== NOT EXECUTED 10c221: e8 c2 36 00 00 call 10f8e8 <_TOD_Get_uptime> <== NOT EXECUTED _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 10c226: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c229: 57 push %edi <== NOT EXECUTED 10c22a: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10c22d: 50 push %eax <== NOT EXECUTED 10c22e: 68 84 f8 11 00 push $0x11f884 <== NOT EXECUTED 10c233: e8 7c 0d 00 00 call 10cfb4 <_Timespec_Subtract> <== NOT EXECUTED _Timespec_Add_to( &executing->cpu_time_used, &ran ); 10c238: 58 pop %eax <== NOT EXECUTED 10c239: 5a pop %edx <== NOT EXECUTED 10c23a: 57 push %edi <== NOT EXECUTED 10c23b: 8d 86 84 00 00 00 lea 0x84(%esi),%eax <== NOT EXECUTED 10c241: 50 push %eax <== NOT EXECUTED 10c242: e8 35 0d 00 00 call 10cf7c <_Timespec_Add_to> <== NOT EXECUTED _Thread_Time_of_last_context_switch = uptime; 10c247: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10c24a: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10c24d: a3 84 f8 11 00 mov %eax,0x11f884 <== NOT EXECUTED 10c252: 89 15 88 f8 11 00 mov %edx,0x11f888 <== NOT EXECUTED #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10c258: 8b 15 44 f8 11 00 mov 0x11f844,%edx <== NOT EXECUTED 10c25e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c261: 85 d2 test %edx,%edx <== NOT EXECUTED 10c263: 74 10 je 10c275 <_Thread_Dispatch+0x85> <== NOT EXECUTED executing->libc_reent = *_Thread_libc_reent; 10c265: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10c267: 89 86 f0 00 00 00 mov %eax,0xf0(%esi) <== NOT EXECUTED *_Thread_libc_reent = heir->libc_reent; 10c26d: 8b 83 f0 00 00 00 mov 0xf0(%ebx),%eax <== NOT EXECUTED 10c273: 89 02 mov %eax,(%edx) <== NOT EXECUTED } _User_extensions_Thread_switch( executing, heir ); 10c275: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c278: 53 push %ebx <== NOT EXECUTED 10c279: 56 push %esi <== NOT EXECUTED 10c27a: e8 9d 0f 00 00 call 10d21c <_User_extensions_Thread_switch> <== NOT EXECUTED if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10c27f: 59 pop %ecx <== NOT EXECUTED 10c280: 58 pop %eax <== NOT EXECUTED 10c281: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax <== NOT EXECUTED 10c287: 50 push %eax <== NOT EXECUTED 10c288: 8d 86 d4 00 00 00 lea 0xd4(%esi),%eax <== NOT EXECUTED 10c28e: 50 push %eax <== NOT EXECUTED 10c28f: e8 8c 12 00 00 call 10d520 <_CPU_Context_switch> <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10c294: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c297: 8b 96 ec 00 00 00 mov 0xec(%esi),%edx <== NOT EXECUTED 10c29d: 85 d2 test %edx,%edx <== NOT EXECUTED 10c29f: 74 36 je 10c2d7 <_Thread_Dispatch+0xe7> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10c2a1: a1 40 f8 11 00 mov 0x11f840,%eax <== NOT EXECUTED 10c2a6: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10c2a8: 74 2d je 10c2d7 <_Thread_Dispatch+0xe7> <== NOT EXECUTED !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10c2aa: 85 c0 test %eax,%eax <== NOT EXECUTED 10c2ac: 74 11 je 10c2bf <_Thread_Dispatch+0xcf> <== NOT EXECUTED _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10c2ae: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c2b1: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10c2b6: 50 push %eax <== NOT EXECUTED 10c2b7: e8 98 12 00 00 call 10d554 <_CPU_Context_save_fp> <== NOT EXECUTED 10c2bc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Context_Restore_fp( &executing->fp_context ); 10c2bf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c2c2: 8d 86 ec 00 00 00 lea 0xec(%esi),%eax <== NOT EXECUTED 10c2c8: 50 push %eax <== NOT EXECUTED 10c2c9: e8 90 12 00 00 call 10d55e <_CPU_Context_restore_fp> <== NOT EXECUTED _Thread_Allocated_fp = executing; 10c2ce: 89 35 40 f8 11 00 mov %esi,0x11f840 <== NOT EXECUTED 10c2d4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10c2d7: 8b 35 7c f8 11 00 mov 0x11f87c,%esi <== NOT EXECUTED _ISR_Disable( level ); 10c2dd: 9c pushf <== NOT EXECUTED 10c2de: fa cli <== NOT EXECUTED 10c2df: 5a pop %edx <== NOT EXECUTED Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Context_Switch_necessary == TRUE ) { 10c2e0: a0 8c f8 11 00 mov 0x11f88c,%al <== NOT EXECUTED 10c2e5: 84 c0 test %al,%al <== NOT EXECUTED 10c2e7: 74 37 je 10c320 <_Thread_Dispatch+0x130> <== NOT EXECUTED heir = _Thread_Heir; 10c2e9: 8b 1d 48 f8 11 00 mov 0x11f848,%ebx <== NOT EXECUTED _Thread_Dispatch_disable_level = 1; 10c2ef: c7 05 b8 f7 11 00 01 movl $0x1,0x11f7b8 <== NOT EXECUTED 10c2f6: 00 00 00 <== NOT EXECUTED _Context_Switch_necessary = FALSE; 10c2f9: c6 05 8c f8 11 00 00 movb $0x0,0x11f88c <== NOT EXECUTED _Thread_Executing = heir; 10c300: 89 1d 7c f8 11 00 mov %ebx,0x11f87c <== NOT EXECUTED #if __RTEMS_ADA__ executing->rtems_ada_self = rtems_ada_self; rtems_ada_self = heir->rtems_ada_self; #endif if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) 10c306: 83 7b 7c 01 cmpl $0x1,0x7c(%ebx) <== NOT EXECUTED 10c30a: 0f 85 08 ff ff ff jne 10c218 <_Thread_Dispatch+0x28> <== NOT EXECUTED heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c310: a1 84 f7 11 00 mov 0x11f784,%eax <== NOT EXECUTED 10c315: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10c318: e9 fb fe ff ff jmp 10c218 <_Thread_Dispatch+0x28> <== NOT EXECUTED 10c31d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED executing = _Thread_Executing; _ISR_Disable( level ); } _Thread_Dispatch_disable_level = 0; 10c320: c7 05 b8 f7 11 00 00 movl $0x0,0x11f7b8 <== NOT EXECUTED 10c327: 00 00 00 <== NOT EXECUTED _ISR_Enable( level ); 10c32a: 52 push %edx <== NOT EXECUTED 10c32b: 9d popf <== NOT EXECUTED if ( _Thread_Do_post_task_switch_extension || 10c32c: a1 60 f8 11 00 mov 0x11f860,%eax <== NOT EXECUTED 10c331: 85 c0 test %eax,%eax <== NOT EXECUTED 10c333: 75 06 jne 10c33b <_Thread_Dispatch+0x14b> <== NOT EXECUTED 10c335: 80 7e 75 00 cmpb $0x0,0x75(%esi) <== NOT EXECUTED 10c339: 74 09 je 10c344 <_Thread_Dispatch+0x154> <== NOT EXECUTED executing->do_post_task_switch_extension ) { executing->do_post_task_switch_extension = false; 10c33b: c6 46 75 00 movb $0x0,0x75(%esi) <== NOT EXECUTED _API_extensions_Run_postswitch(); 10c33f: e8 74 e9 ff ff call 10acb8 <_API_extensions_Run_postswitch> <== NOT EXECUTED } } 10c344: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c347: 5b pop %ebx <== NOT EXECUTED 10c348: 5e pop %esi <== NOT EXECUTED 10c349: 5f pop %edi <== NOT EXECUTED 10c34a: c9 leave <== NOT EXECUTED 10c34b: c3 ret <== NOT EXECUTED 0010c34c <_Thread_Enable_dispatch>: */ #if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \ (__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) ) void _Thread_Enable_dispatch( void ) { 10c34c: 55 push %ebp <== NOT EXECUTED 10c34d: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( --_Thread_Dispatch_disable_level ) 10c34f: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10c354: 48 dec %eax <== NOT EXECUTED 10c355: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED 10c35a: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10c35f: 85 c0 test %eax,%eax <== NOT EXECUTED 10c361: 74 05 je 10c368 <_Thread_Enable_dispatch+0x1c> <== NOT EXECUTED return; _Thread_Dispatch(); } 10c363: c9 leave <== NOT EXECUTED 10c364: c3 ret <== NOT EXECUTED 10c365: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10c368: c9 leave <== NOT EXECUTED (__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) ) void _Thread_Enable_dispatch( void ) { if ( --_Thread_Dispatch_disable_level ) return; _Thread_Dispatch(); 10c369: e9 82 fe ff ff jmp 10c1f0 <_Thread_Dispatch> <== NOT EXECUTED 00110a24 <_Thread_Evaluate_mode>: * * XXX */ bool _Thread_Evaluate_mode( void ) { 110a24: 55 push %ebp <== NOT EXECUTED 110a25: 89 e5 mov %esp,%ebp <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 110a27: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED if ( !_States_Is_ready( executing->current_state ) || 110a2c: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 110a2f: 85 d2 test %edx,%edx <== NOT EXECUTED 110a31: 75 0e jne 110a41 <_Thread_Evaluate_mode+0x1d> <== NOT EXECUTED 110a33: 3b 05 48 f8 11 00 cmp 0x11f848,%eax <== NOT EXECUTED 110a39: 74 11 je 110a4c <_Thread_Evaluate_mode+0x28> <== NOT EXECUTED 110a3b: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 110a3f: 74 0b je 110a4c <_Thread_Evaluate_mode+0x28> <== NOT EXECUTED ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; 110a41: c6 05 8c f8 11 00 01 movb $0x1,0x11f88c <== NOT EXECUTED 110a48: b0 01 mov $0x1,%al <== NOT EXECUTED return TRUE; } return FALSE; } 110a4a: c9 leave <== NOT EXECUTED 110a4b: c3 ret <== NOT EXECUTED executing = _Thread_Executing; if ( !_States_Is_ready( executing->current_state ) || ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; return TRUE; 110a4c: 31 c0 xor %eax,%eax <== NOT EXECUTED } return FALSE; } 110a4e: c9 leave <== NOT EXECUTED 110a4f: c3 ret <== NOT EXECUTED 0010c370 <_Thread_Get>: Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) { 10c370: 55 push %ebp <== NOT EXECUTED 10c371: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c373: 53 push %ebx <== NOT EXECUTED 10c374: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10c377: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c37a: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED uint32_t the_class; Objects_Information **api_information; Objects_Information *information; Thread_Control *tp = (Thread_Control *) 0; if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) ) { 10c37d: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10c37f: 74 4b je 10c3cc <_Thread_Get+0x5c> <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10c381: 89 ca mov %ecx,%edx <== NOT EXECUTED 10c383: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10c386: 83 e2 07 and $0x7,%edx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10c389: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10c38c: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10c38f: 77 2b ja 10c3bc <_Thread_Get+0x4c> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 10c391: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10c393: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED 10c396: 48 dec %eax <== NOT EXECUTED 10c397: 75 23 jne 10c3bc <_Thread_Get+0x4c> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } api_information = _Objects_Information_table[ the_api ]; 10c399: 8b 04 95 8c f7 11 00 mov 0x11f78c(,%edx,4),%eax <== NOT EXECUTED if ( !api_information ) { 10c3a0: 85 c0 test %eax,%eax <== NOT EXECUTED 10c3a2: 74 44 je 10c3e8 <_Thread_Get+0x78> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = api_information[ the_class ]; 10c3a4: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED if ( !information ) { 10c3a7: 85 c0 test %eax,%eax <== NOT EXECUTED 10c3a9: 74 3d je 10c3e8 <_Thread_Get+0x78> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 10c3ab: 52 push %edx <== NOT EXECUTED 10c3ac: 53 push %ebx <== NOT EXECUTED 10c3ad: 51 push %ecx <== NOT EXECUTED 10c3ae: 50 push %eax <== NOT EXECUTED 10c3af: e8 54 f7 ff ff call 10bb08 <_Objects_Get> <== NOT EXECUTED 10c3b4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED done: return tp; } 10c3b7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c3ba: c9 leave <== NOT EXECUTED 10c3bb: c3 ret <== NOT EXECUTED goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ *location = OBJECTS_ERROR; 10c3bc: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 10c3c2: 31 c0 xor %eax,%eax <== NOT EXECUTED tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10c3c4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c3c7: c9 leave <== NOT EXECUTED 10c3c8: c3 ret <== NOT EXECUTED 10c3c9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10c3cc: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10c3d1: 40 inc %eax <== NOT EXECUTED 10c3d2: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== 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; 10c3d7: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED tp = _Thread_Executing; 10c3dd: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10c3e2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c3e5: c9 leave <== NOT EXECUTED 10c3e6: c3 ret <== NOT EXECUTED 10c3e7: 90 nop <== NOT EXECUTED goto done; } information = api_information[ the_class ]; if ( !information ) { *location = OBJECTS_ERROR; 10c3e8: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 10c3ee: eb d4 jmp 10c3c4 <_Thread_Get+0x54> <== NOT EXECUTED 00110a50 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 110a50: 55 push %ebp <== NOT EXECUTED 110a51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110a53: 53 push %ebx <== NOT EXECUTED 110a54: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 110a57: 8b 1d 7c f8 11 00 mov 0x11f87c,%ebx <== NOT EXECUTED /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 110a5d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED _ISR_Set_level(level); 110a63: 85 c0 test %eax,%eax <== NOT EXECUTED 110a65: 0f 84 91 00 00 00 je 110afc <_Thread_Handler+0xac> <== NOT EXECUTED 110a6b: fa cli <== NOT EXECUTED #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 110a6c: a0 78 f5 11 00 mov 0x11f578,%al <== NOT EXECUTED 110a71: 88 45 fb mov %al,-0x5(%ebp) <== NOT EXECUTED doneConstructors = 1; 110a74: c6 05 78 f5 11 00 01 movb $0x1,0x11f578 <== NOT EXECUTED #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 ) ) { 110a7b: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax <== NOT EXECUTED 110a81: 85 c0 test %eax,%eax <== NOT EXECUTED 110a83: 74 24 je 110aa9 <_Thread_Handler+0x59> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 110a85: a1 40 f8 11 00 mov 0x11f840,%eax <== NOT EXECUTED 110a8a: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 110a8c: 74 1b je 110aa9 <_Thread_Handler+0x59> <== NOT EXECUTED if ( _Thread_Allocated_fp != NULL ) 110a8e: 85 c0 test %eax,%eax <== NOT EXECUTED 110a90: 74 11 je 110aa3 <_Thread_Handler+0x53> <== NOT EXECUTED _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 110a92: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110a95: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 110a9a: 50 push %eax <== NOT EXECUTED 110a9b: e8 b4 ca ff ff call 10d554 <_CPU_Context_save_fp> <== NOT EXECUTED 110aa0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Allocated_fp = executing; 110aa3: 89 1d 40 f8 11 00 mov %ebx,0x11f840 <== NOT EXECUTED * 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 ); 110aa9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110aac: 53 push %ebx <== NOT EXECUTED 110aad: e8 e2 c5 ff ff call 10d094 <_User_extensions_Thread_begin> <== NOT EXECUTED /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 110ab2: e8 95 b8 ff ff call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED /* * _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) */ 110ab7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110aba: 80 7d fb 00 cmpb $0x0,-0x5(%ebp) <== NOT EXECUTED 110abe: 74 6c je 110b2c <_Thread_Handler+0xdc> <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 110ac0: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax <== NOT EXECUTED 110ac6: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 110ac9: 74 71 je 110b3c <_Thread_Handler+0xec> <== NOT EXECUTED 110acb: 73 37 jae 110b04 <_Thread_Handler+0xb4> <== NOT EXECUTED case THREAD_START_NUMERIC: executing->Wait.return_argument = 110acd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110ad0: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 110ad6: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 110adc: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 110adf: 83 c4 10 add $0x10,%esp <== 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 ); 110ae2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110ae5: 53 push %ebx <== NOT EXECUTED 110ae6: e8 e5 c5 ff ff call 10d0d0 <_User_extensions_Thread_exitted> <== NOT EXECUTED _Internal_error_Occurred( 110aeb: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 110aee: 6a 06 push $0x6 <== NOT EXECUTED 110af0: 6a 01 push $0x1 <== NOT EXECUTED 110af2: 6a 00 push $0x0 <== NOT EXECUTED 110af4: e8 87 aa ff ff call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 110af9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * 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); 110afc: fb sti <== NOT EXECUTED 110afd: e9 6a ff ff ff jmp 110a6c <_Thread_Handler+0x1c> <== NOT EXECUTED 110b02: 66 90 xchg %ax,%ax <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 110b04: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 110b07: 74 4b je 110b54 <_Thread_Handler+0x104> <== NOT EXECUTED 110b09: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 110b0c: 75 d4 jne 110ae2 <_Thread_Handler+0x92> <== NOT EXECUTED executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 110b0e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 110b11: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 110b17: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 110b1d: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 110b23: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 110b26: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110b29: eb b7 jmp 110ae2 <_Thread_Handler+0x92> <== NOT EXECUTED 110b2b: 90 nop <== NOT EXECUTED * in any configuration I know of and it generates a warning on every * RTEMS target configuration. --joel (12 May 2007) */ if (!doneCons) /* && (volatile void *)_init) */ { _init (); 110b2c: e8 ff 6d 00 00 call 117930 <__start_set_sysctl_set> <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 110b31: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax <== NOT EXECUTED 110b37: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 110b3a: 75 8f jne 110acb <_Thread_Handler+0x7b> <== NOT EXECUTED (*(Thread_Entry_numeric) executing->Start.entry_point)( executing->Start.numeric_argument ); break; case THREAD_START_POINTER: executing->Wait.return_argument = 110b3c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110b3f: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 110b45: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 110b4b: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 110b4e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110b51: eb 8f jmp 110ae2 <_Thread_Handler+0x92> <== NOT EXECUTED 110b53: 90 nop <== NOT EXECUTED (*(Thread_Entry_pointer) executing->Start.entry_point)( executing->Start.pointer_argument ); break; case THREAD_START_BOTH_POINTER_FIRST: executing->Wait.return_argument = 110b54: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 110b57: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 110b5d: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 110b63: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 110b69: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 110b6c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110b6f: e9 6e ff ff ff jmp 110ae2 <_Thread_Handler+0x92> <== NOT EXECUTED 0010c5f8 <_Thread_Handler_initialization>: #if defined(RTEMS_MULTIPROCESSING) , uint32_t maximum_proxies #endif ) { 10c5f8: 55 push %ebp <== NOT EXECUTED 10c5f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c5fb: 53 push %ebx <== NOT EXECUTED 10c5fc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED /* * BOTH stacks hooks must be set or both must be NULL. * Do not allow mixture. */ if ( !( (!_Configuration_Table->stack_allocate_hook) 10c5ff: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10c604: 8b 58 20 mov 0x20(%eax),%ebx <== NOT EXECUTED 10c607: 85 db test %ebx,%ebx <== NOT EXECUTED 10c609: 0f 94 c2 sete %dl <== NOT EXECUTED 10c60c: 8b 48 24 mov 0x24(%eax),%ecx <== NOT EXECUTED 10c60f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10c611: 0f 94 c0 sete %al <== NOT EXECUTED 10c614: 38 c2 cmp %al,%dl <== NOT EXECUTED 10c616: 0f 85 a5 00 00 00 jne 10c6c1 <_Thread_Handler_initialization+0xc9> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 10c61c: c6 05 8c f8 11 00 00 movb $0x0,0x11f88c <== NOT EXECUTED _Thread_Executing = NULL; 10c623: c7 05 7c f8 11 00 00 movl $0x0,0x11f87c <== NOT EXECUTED 10c62a: 00 00 00 <== NOT EXECUTED _Thread_Heir = NULL; 10c62d: c7 05 48 f8 11 00 00 movl $0x0,0x11f848 <== NOT EXECUTED 10c634: 00 00 00 <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 10c637: c7 05 40 f8 11 00 00 movl $0x0,0x11f840 <== NOT EXECUTED 10c63e: 00 00 00 <== NOT EXECUTED #endif _Thread_Do_post_task_switch_extension = 0; 10c641: c7 05 60 f8 11 00 00 movl $0x0,0x11f860 <== NOT EXECUTED 10c648: 00 00 00 <== NOT EXECUTED _Thread_Maximum_extensions = maximum_extensions; 10c64b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c64e: a3 5c f8 11 00 mov %eax,0x11f85c <== NOT EXECUTED _Thread_Ticks_per_timeslice = ticks_per_timeslice; 10c653: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c656: a3 84 f7 11 00 mov %eax,0x11f784 <== NOT EXECUTED _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error( 10c65b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c65e: 0f b6 05 d4 b1 11 00 movzbl 0x11b1d4,%eax <== NOT EXECUTED 10c665: 8d 44 40 03 lea 0x3(%eax,%eax,2),%eax <== NOT EXECUTED 10c669: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10c66c: 50 push %eax <== NOT EXECUTED 10c66d: e8 26 0e 00 00 call 10d498 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10c672: a3 80 f7 11 00 mov %eax,0x11f780 <== NOT EXECUTED (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control) ); for ( index=0; index <= PRIORITY_MAXIMUM ; index++ ) 10c677: 0f b6 1d d4 b1 11 00 movzbl 0x11b1d4,%ebx <== NOT EXECUTED 10c67e: 89 c2 mov %eax,%edx <== NOT EXECUTED 10c680: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10c682: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c685: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10c688: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10c68b: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10c68d: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10c694: 89 52 08 mov %edx,0x8(%edx) <== NOT EXECUTED 10c697: 41 inc %ecx <== NOT EXECUTED 10c698: 83 c2 0c add $0xc,%edx <== NOT EXECUTED 10c69b: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 10c69d: 76 e9 jbe 10c688 <_Thread_Handler_initialization+0x90> <== NOT EXECUTED /* * Initialize this class of objects. */ _Objects_Initialize_information( 10c69f: 50 push %eax <== NOT EXECUTED 10c6a0: 6a 08 push $0x8 <== NOT EXECUTED 10c6a2: 6a 01 push $0x1 <== NOT EXECUTED 10c6a4: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10c6a9: 6a 01 push $0x1 <== NOT EXECUTED 10c6ab: 6a 01 push $0x1 <== NOT EXECUTED 10c6ad: 6a 01 push $0x1 <== NOT EXECUTED 10c6af: 68 40 f9 11 00 push $0x11f940 <== NOT EXECUTED 10c6b4: e8 b3 f4 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED 10c6b9: 83 c4 20 add $0x20,%esp <== NOT EXECUTED FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10c6bc: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c6bf: c9 leave <== NOT EXECUTED 10c6c0: c3 ret <== NOT EXECUTED * BOTH stacks hooks must be set or both must be NULL. * Do not allow mixture. */ if ( !( (!_Configuration_Table->stack_allocate_hook) == (!_Configuration_Table->stack_free_hook) ) ) _Internal_error_Occurred( 10c6c1: 52 push %edx <== NOT EXECUTED 10c6c2: 6a 0f push $0xf <== NOT EXECUTED 10c6c4: 6a 01 push $0x1 <== NOT EXECUTED 10c6c6: 6a 00 push $0x0 <== NOT EXECUTED 10c6c8: e8 b3 ee ff ff call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 0010c3f0 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10c3f0: 55 push %ebp <== NOT EXECUTED 10c3f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c3f3: 57 push %edi <== NOT EXECUTED 10c3f4: 56 push %esi <== NOT EXECUTED 10c3f5: 53 push %ebx <== NOT EXECUTED 10c3f6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c3f9: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10c3fc: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10c3ff: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 10c402: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED 10c405: 8a 4d 20 mov 0x20(%ebp),%cl <== NOT EXECUTED 10c408: 88 4d f2 mov %cl,-0xe(%ebp) <== NOT EXECUTED /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 10c40b: 85 d2 test %edx,%edx <== NOT EXECUTED 10c40d: 0f 84 b2 01 00 00 je 10c5c5 <_Thread_Initialize+0x1d5> <== NOT EXECUTED 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; 10c413: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx) <== NOT EXECUTED 10c41a: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of 10c41d: 89 93 c8 00 00 00 mov %edx,0xc8(%ebx) <== NOT EXECUTED * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 10c423: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx) <== NOT EXECUTED /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 10c429: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10c42d: 0f 85 2d 01 00 00 jne 10c560 <_Thread_Initialize+0x170> <== NOT EXECUTED fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) { _Thread_Stack_Free( the_thread ); return FALSE; 10c433: 31 ff xor %edi,%edi <== NOT EXECUTED 10c435: 31 c0 xor %eax,%eax <== NOT EXECUTED fp_area = _Context_Fp_start( fp_area, 0 ); } else fp_area = NULL; the_thread->fp_context = fp_area; 10c437: 89 83 ec 00 00 00 mov %eax,0xec(%ebx) <== NOT EXECUTED the_thread->Start.fp_context = fp_area; 10c43d: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) <== NOT EXECUTED * 10c443: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10c44a: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10c451: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) <== NOT EXECUTED * the heap 10c458: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED /* * Clear the libc reent hook. */ the_thread->libc_reent = NULL; 10c45f: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx) <== NOT EXECUTED 10c466: 00 00 00 <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c469: a1 5c f8 11 00 mov 0x11f85c,%eax <== NOT EXECUTED 10c46e: 85 c0 test %eax,%eax <== NOT EXECUTED 10c470: 0f 85 06 01 00 00 jne 10c57c <_Thread_Initialize+0x18c> <== NOT EXECUTED return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 10c476: c7 83 00 01 00 00 00 movl $0x0,0x100(%ebx) <== NOT EXECUTED 10c47d: 00 00 00 <== NOT EXECUTED 10c480: 31 f6 xor %esi,%esi <== NOT EXECUTED /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10c482: 8a 45 f2 mov -0xe(%ebp),%al <== NOT EXECUTED 10c485: 88 83 ac 00 00 00 mov %al,0xac(%ebx) <== NOT EXECUTED the_thread->Start.budget_algorithm = budget_algorithm; 10c48b: 8b 4d 24 mov 0x24(%ebp),%ecx <== NOT EXECUTED 10c48e: 89 8b b0 00 00 00 mov %ecx,0xb0(%ebx) <== NOT EXECUTED the_thread->Start.budget_callout = budget_callout; 10c494: 8b 45 28 mov 0x28(%ebp),%eax <== NOT EXECUTED 10c497: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) <== NOT EXECUTED switch ( budget_algorithm ) { 10c49d: 83 f9 02 cmp $0x2,%ecx <== NOT EXECUTED 10c4a0: 75 08 jne 10c4aa <_Thread_Initialize+0xba> <== NOT EXECUTED 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; 10c4a2: a1 84 f7 11 00 mov 0x11f784,%eax <== NOT EXECUTED 10c4a7: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 10c4aa: 8b 4d 2c mov 0x2c(%ebp),%ecx <== NOT EXECUTED 10c4ad: 89 8b b8 00 00 00 mov %ecx,0xb8(%ebx) <== NOT EXECUTED the_thread->current_state = STATES_DORMANT; 10c4b3: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) <== NOT EXECUTED the_thread->Wait.queue = NULL; 10c4ba: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED the_thread->resource_count = 0; 10c4c1: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED the_thread->suspend_count = 0; 10c4c8: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED the_thread->real_priority = priority; 10c4cf: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 10c4d2: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED the_thread->Start.initial_priority = priority; 10c4d5: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) <== NOT EXECUTED _Thread_Set_priority( the_thread, priority ); 10c4db: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c4de: 50 push %eax <== NOT EXECUTED 10c4df: 53 push %ebx <== NOT EXECUTED 10c4e0: e8 af 06 00 00 call 10cb94 <_Thread_Set_priority> <== NOT EXECUTED /* * Initialize the CPU usage statistics */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS the_thread->cpu_time_used.tv_sec = 0; 10c4e5: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) <== NOT EXECUTED 10c4ec: 00 00 00 <== NOT EXECUTED the_thread->cpu_time_used.tv_nsec = 0; 10c4ef: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) <== NOT EXECUTED 10c4f6: 00 00 00 <== NOT EXECUTED 10c4f9: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 10c4fd: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c500: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 10c503: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10c506: 8b 45 30 mov 0x30(%ebp),%eax <== NOT EXECUTED 10c509: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED * enabled when we get here. We want to be able to run the * user extensions with dispatching enabled. The Allocator * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread ); 10c50c: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10c50f: e8 40 0c 00 00 call 10d154 <_User_extensions_Thread_create> <== NOT EXECUTED if ( !extension_status ) { 10c514: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c517: 84 c0 test %al,%al <== NOT EXECUTED 10c519: 75 39 jne 10c554 <_Thread_Initialize+0x164> <== NOT EXECUTED if ( extensions_area ) 10c51b: 85 f6 test %esi,%esi <== NOT EXECUTED 10c51d: 74 0c je 10c52b <_Thread_Initialize+0x13b> <== NOT EXECUTED (void) _Workspace_Free( extensions_area ); 10c51f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c522: 56 push %esi <== NOT EXECUTED 10c523: e8 40 0f 00 00 call 10d468 <_Workspace_Free> <== NOT EXECUTED 10c528: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 10c52b: 85 ff test %edi,%edi <== NOT EXECUTED 10c52d: 74 0c je 10c53b <_Thread_Initialize+0x14b> <== NOT EXECUTED (void) _Workspace_Free( fp_area ); 10c52f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c532: 57 push %edi <== NOT EXECUTED 10c533: e8 30 0f 00 00 call 10d468 <_Workspace_Free> <== NOT EXECUTED 10c538: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 10c53b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c53e: 53 push %ebx <== NOT EXECUTED 10c53f: e8 6c 08 00 00 call 10cdb0 <_Thread_Stack_Free> <== NOT EXECUTED 10c544: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c546: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return FALSE; } return TRUE; } 10c549: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c54c: 5b pop %ebx <== NOT EXECUTED 10c54d: 5e pop %esi <== NOT EXECUTED 10c54e: 5f pop %edi <== NOT EXECUTED 10c54f: c9 leave <== NOT EXECUTED 10c550: c3 ret <== NOT EXECUTED 10c551: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread ); if ( !extension_status ) { 10c554: b0 01 mov $0x1,%al <== NOT EXECUTED return FALSE; } return TRUE; } 10c556: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c559: 5b pop %ebx <== NOT EXECUTED 10c55a: 5e pop %esi <== NOT EXECUTED 10c55b: 5f pop %edi <== NOT EXECUTED 10c55c: c9 leave <== NOT EXECUTED 10c55d: c3 ret <== NOT EXECUTED 10c55e: 66 90 xchg %ax,%ax <== NOT EXECUTED */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10c560: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c563: 6a 6c push $0x6c <== NOT EXECUTED 10c565: e8 16 0f 00 00 call 10d480 <_Workspace_Allocate> <== NOT EXECUTED 10c56a: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( !fp_area ) { 10c56c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c56f: 85 c0 test %eax,%eax <== NOT EXECUTED 10c571: 0f 85 c0 fe ff ff jne 10c437 <_Thread_Initialize+0x47> <== NOT EXECUTED 10c577: eb c2 jmp 10c53b <_Thread_Initialize+0x14b> <== NOT EXECUTED 10c579: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( 10c57c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c57f: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax <== NOT EXECUTED 10c586: 50 push %eax <== NOT EXECUTED 10c587: e8 f4 0e 00 00 call 10d480 <_Workspace_Allocate> <== NOT EXECUTED 10c58c: 89 c6 mov %eax,%esi <== NOT EXECUTED (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 10c58e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c591: 85 c0 test %eax,%eax <== NOT EXECUTED 10c593: 74 96 je 10c52b <_Thread_Initialize+0x13b> <== NOT EXECUTED return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 10c595: 89 83 00 01 00 00 mov %eax,0x100(%ebx) <== NOT EXECUTED * call. */ if ( the_thread->extensions ) { uint32_t i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 10c59b: 83 3d 5c f8 11 00 ff cmpl $0xffffffff,0x11f85c <== NOT EXECUTED 10c5a2: 0f 84 da fe ff ff je 10c482 <_Thread_Initialize+0x92> <== NOT EXECUTED 10c5a8: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c5aa: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10c5ac: a1 5c f8 11 00 mov 0x11f85c,%eax <== NOT EXECUTED 10c5b1: 40 inc %eax <== NOT EXECUTED 10c5b2: 66 90 xchg %ax,%ax <== NOT EXECUTED the_thread->extensions[i] = NULL; 10c5b4: c7 04 91 00 00 00 00 movl $0x0,(%ecx,%edx,4) <== NOT EXECUTED * call. */ if ( the_thread->extensions ) { uint32_t i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 10c5bb: 42 inc %edx <== NOT EXECUTED 10c5bc: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10c5be: 77 f4 ja 10c5b4 <_Thread_Initialize+0x1c4> <== NOT EXECUTED 10c5c0: e9 bd fe ff ff jmp 10c482 <_Thread_Initialize+0x92> <== NOT EXECUTED */ if ( !stack_area ) { actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10c5c5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c5c8: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10c5cb: 53 push %ebx <== NOT EXECUTED 10c5cc: e8 7b 07 00 00 call 10cd4c <_Thread_Stack_Allocate> <== NOT EXECUTED if ( !actual_stack_size || actual_stack_size < stack_size ) 10c5d1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c5d4: 85 c0 test %eax,%eax <== NOT EXECUTED 10c5d6: 74 17 je 10c5ef <_Thread_Initialize+0x1ff> <== NOT EXECUTED 10c5d8: 39 45 14 cmp %eax,0x14(%ebp) <== NOT EXECUTED 10c5db: 77 12 ja 10c5ef <_Thread_Initialize+0x1ff> <== NOT EXECUTED return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 10c5dd: 8b 93 d0 00 00 00 mov 0xd0(%ebx),%edx <== NOT EXECUTED the_thread->Start.core_allocated_stack = TRUE; 10c5e3: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx) <== NOT EXECUTED 10c5ea: e9 2e fe ff ff jmp 10c41d <_Thread_Initialize+0x2d> <== NOT EXECUTED (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); return FALSE; 10c5ef: 31 c0 xor %eax,%eax 10c5f1: e9 53 ff ff ff jmp 10c549 <_Thread_Initialize+0x159> <== NOT EXECUTED 0010fb78 <_Thread_Load_environment>: */ void _Thread_Load_environment( Thread_Control *the_thread ) { 10fb78: 55 push %ebp <== NOT EXECUTED 10fb79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fb7b: 57 push %edi <== NOT EXECUTED 10fb7c: 56 push %esi <== NOT EXECUTED 10fb7d: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10fb80: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED bool is_fp; #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( the_thread->Start.fp_context ) { 10fb83: 8b ba cc 00 00 00 mov 0xcc(%edx),%edi <== NOT EXECUTED 10fb89: 85 ff test %edi,%edi <== NOT EXECUTED 10fb8b: 74 12 je 10fb9f <_Thread_Load_environment+0x27> <== NOT EXECUTED the_thread->fp_context = the_thread->Start.fp_context; 10fb8d: 89 ba ec 00 00 00 mov %edi,0xec(%edx) <== NOT EXECUTED _Context_Initialize_fp( &the_thread->fp_context ); 10fb93: be a0 f9 11 00 mov $0x11f9a0,%esi <== NOT EXECUTED 10fb98: b9 1b 00 00 00 mov $0x1b,%ecx <== NOT EXECUTED 10fb9d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED } else #endif is_fp = false; the_thread->do_post_task_switch_extension = false; 10fb9f: c6 42 75 00 movb $0x0,0x75(%edx) <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 10fba3: 8a 82 ac 00 00 00 mov 0xac(%edx),%al <== NOT EXECUTED 10fba9: 88 42 76 mov %al,0x76(%edx) <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 10fbac: 8b 82 b0 00 00 00 mov 0xb0(%edx),%eax <== NOT EXECUTED 10fbb2: 89 42 7c mov %eax,0x7c(%edx) <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 10fbb5: 8b 82 b4 00 00 00 mov 0xb4(%edx),%eax <== NOT EXECUTED 10fbbb: 89 82 80 00 00 00 mov %eax,0x80(%edx) <== NOT EXECUTED _Context_Initialize( 10fbc1: 83 ba b8 00 00 00 01 cmpl $0x1,0xb8(%edx) <== NOT EXECUTED 10fbc8: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10fbca: 25 00 02 00 00 and $0x200,%eax <== NOT EXECUTED 10fbcf: 05 02 30 00 00 add $0x3002,%eax <== NOT EXECUTED 10fbd4: 89 82 d4 00 00 00 mov %eax,0xd4(%edx) <== NOT EXECUTED 10fbda: 8b 82 c4 00 00 00 mov 0xc4(%edx),%eax <== NOT EXECUTED 10fbe0: 83 e8 04 sub $0x4,%eax <== NOT EXECUTED 10fbe3: 03 82 c8 00 00 00 add 0xc8(%edx),%eax <== NOT EXECUTED 10fbe9: c7 00 50 0a 11 00 movl $0x110a50,(%eax) <== NOT EXECUTED 10fbef: 89 82 dc 00 00 00 mov %eax,0xdc(%edx) <== NOT EXECUTED 10fbf5: 89 82 d8 00 00 00 mov %eax,0xd8(%edx) <== NOT EXECUTED the_thread->Start.isr_level, _Thread_Handler, is_fp ); } 10fbfb: 58 pop %eax <== NOT EXECUTED 10fbfc: 5e pop %esi <== NOT EXECUTED 10fbfd: 5f pop %edi <== NOT EXECUTED 10fbfe: c9 leave <== NOT EXECUTED 10fbff: c3 ret <== NOT EXECUTED 0010fdfc <_Thread_Ready>: */ void _Thread_Ready( Thread_Control *the_thread ) { 10fdfc: 55 push %ebp <== NOT EXECUTED 10fdfd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fdff: 53 push %ebx <== NOT EXECUTED 10fe00: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Thread_Control *heir; _ISR_Disable( level ); 10fe03: 9c pushf <== NOT EXECUTED 10fe04: fa cli <== NOT EXECUTED 10fe05: 5b pop %ebx <== NOT EXECUTED the_thread->current_state = STATES_READY; 10fe06: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx) <== NOT EXECUTED * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in 10fe0d: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10fe13: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10fe1a: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10fe1d: 66 a1 70 f8 11 00 mov 0x11f870,%ax <== NOT EXECUTED 10fe23: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10fe29: 66 a3 70 f8 11 00 mov %ax,0x11f870 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node ); 10fe2f: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10fe35: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10fe38: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10fe3a: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10fe3d: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10fe40: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10fe42: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10fe45: 53 push %ebx <== NOT EXECUTED 10fe46: 9d popf <== NOT EXECUTED 10fe47: fa cli <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10fe48: 66 8b 0d 70 f8 11 00 mov 0x11f870,%cx <== NOT EXECUTED 10fe4f: 31 d2 xor %edx,%edx <== NOT EXECUTED 10fe51: 89 d0 mov %edx,%eax <== NOT EXECUTED 10fe53: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10fe57: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10fe5a: 66 8b 8c 00 00 f9 11 mov 0x11f900(%eax,%eax,1),%cx <== NOT EXECUTED 10fe61: 00 <== NOT EXECUTED 10fe62: 66 0f bc d1 bsf %cx,%dx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10fe66: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10fe69: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10fe6c: 01 d0 add %edx,%eax <== NOT EXECUTED 10fe6e: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10fe71: 8b 15 80 f7 11 00 mov 0x11f780,%edx <== NOT EXECUTED 10fe77: 8b 04 82 mov (%edx,%eax,4),%eax <== NOT EXECUTED 10fe7a: a3 48 f8 11 00 mov %eax,0x11f848 <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10fe7f: 8b 15 7c f8 11 00 mov 0x11f87c,%edx <== NOT EXECUTED _Thread_Calculate_heir(); heir = _Thread_Heir; if ( !_Thread_Is_executing( heir ) && _Thread_Executing->is_preemptible ) 10fe85: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10fe87: 74 0d je 10fe96 <_Thread_Ready+0x9a> <== NOT EXECUTED 10fe89: 80 7a 76 00 cmpb $0x0,0x76(%edx) <== NOT EXECUTED 10fe8d: 74 07 je 10fe96 <_Thread_Ready+0x9a> <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10fe8f: c6 05 8c f8 11 00 01 movb $0x1,0x11f88c <== NOT EXECUTED _ISR_Enable( level ); 10fe96: 53 push %ebx <== NOT EXECUTED 10fe97: 9d popf <== NOT EXECUTED } 10fe98: 5b pop %ebx <== NOT EXECUTED 10fe99: c9 leave <== NOT EXECUTED 10fe9a: c3 ret <== NOT EXECUTED 00110a34 <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 110a34: 55 push %ebp <== NOT EXECUTED 110a35: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110a37: 53 push %ebx <== NOT EXECUTED 110a38: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 110a3b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED the_thread->resource_count = 0; 110a3e: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED the_thread->suspend_count = 0; 110a45: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 110a4c: 8a 83 ac 00 00 00 mov 0xac(%ebx),%al <== NOT EXECUTED 110a52: 88 43 76 mov %al,0x76(%ebx) <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 110a55: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 110a5b: 89 43 7c mov %eax,0x7c(%ebx) <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 110a5e: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax <== NOT EXECUTED 110a64: 89 83 80 00 00 00 mov %eax,0x80(%ebx) <== NOT EXECUTED the_thread->Start.pointer_argument = pointer_argument; 110a6a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 110a6d: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) <== NOT EXECUTED the_thread->Start.numeric_argument = numeric_argument; 110a73: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 110a76: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) <== NOT EXECUTED if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 110a7c: 53 push %ebx <== NOT EXECUTED 110a7d: e8 ce c9 ff ff call 10d450 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 110a82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110a85: 84 c0 test %al,%al <== NOT EXECUTED 110a87: 75 06 jne 110a8f <_Thread_Reset+0x5b> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 110a89: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 110a8d: 74 25 je 110ab4 <_Thread_Reset+0x80> <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 110a8f: 8b 83 bc 00 00 00 mov 0xbc(%ebx),%eax <== NOT EXECUTED 110a95: 39 43 14 cmp %eax,0x14(%ebx) <== NOT EXECUTED 110a98: 74 12 je 110aac <_Thread_Reset+0x78> <== NOT EXECUTED the_thread->real_priority = the_thread->Start.initial_priority; 110a9a: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 110a9d: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 110aa0: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 110aa3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110aa6: c9 leave <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { the_thread->real_priority = the_thread->Start.initial_priority; _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 110aa7: e9 a4 cb ff ff jmp 10d650 <_Thread_Set_priority> <== NOT EXECUTED } } 110aac: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110aaf: c9 leave <== NOT EXECUTED 110ab0: c3 ret <== NOT EXECUTED 110ab1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 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 ); 110ab4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110ab7: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 110aba: 50 push %eax <== NOT EXECUTED 110abb: e8 c8 d3 ff ff call 10de88 <_Watchdog_Remove> <== NOT EXECUTED 110ac0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110ac3: eb ca jmp 110a8f <_Thread_Reset+0x5b> <== NOT EXECUTED 0010fe9c <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 10fe9c: 55 push %ebp <== NOT EXECUTED 10fe9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fe9f: 56 push %esi <== NOT EXECUTED 10fea0: 53 push %ebx <== NOT EXECUTED ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10fea1: 8b 0d 7c f8 11 00 mov 0x11f87c,%ecx <== NOT EXECUTED ready = executing->ready; 10fea7: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx <== NOT EXECUTED _ISR_Disable( level ); 10fead: 9c pushf <== NOT EXECUTED 10feae: fa cli <== NOT EXECUTED 10feaf: 5e pop %esi <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10feb0: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10feb2: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10feb5: 74 35 je 10feec <_Thread_Reset_timeslice+0x50> <== NOT EXECUTED 10feb7: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10feb9: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10febc: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10febf: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10fec1: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10fec4: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10fec6: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10fec9: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED 10fecc: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10fece: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED return; } _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 10fed1: 56 push %esi <== NOT EXECUTED 10fed2: 9d popf <== NOT EXECUTED 10fed3: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( executing ) ) 10fed4: 3b 0d 48 f8 11 00 cmp 0x11f848,%ecx <== NOT EXECUTED 10feda: 74 18 je 10fef4 <_Thread_Reset_timeslice+0x58> <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; 10fedc: c6 05 8c f8 11 00 01 movb $0x1,0x11f88c <== NOT EXECUTED _ISR_Enable( level ); 10fee3: 56 push %esi <== NOT EXECUTED 10fee4: 9d popf <== NOT EXECUTED } 10fee5: 5b pop %ebx <== NOT EXECUTED 10fee6: 5e pop %esi <== NOT EXECUTED 10fee7: c9 leave <== NOT EXECUTED 10fee8: c3 ret <== NOT EXECUTED 10fee9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED executing = _Thread_Executing; ready = executing->ready; _ISR_Disable( level ); if ( _Chain_Has_only_one_node( ready ) ) { _ISR_Enable( level ); 10feec: 56 push %esi <== NOT EXECUTED 10feed: 9d popf <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10feee: 5b pop %ebx <== NOT EXECUTED 10feef: 5e pop %esi <== NOT EXECUTED 10fef0: c9 leave <== NOT EXECUTED 10fef1: c3 ret <== NOT EXECUTED 10fef2: 66 90 xchg %ax,%ax <== NOT EXECUTED _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; 10fef4: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10fef6: a3 48 f8 11 00 mov %eax,0x11f848 <== NOT EXECUTED 10fefb: eb df jmp 10fedc <_Thread_Reset_timeslice+0x40> <== NOT EXECUTED 0010d5bc <_Thread_Restart>: bool _Thread_Restart( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10d5bc: 55 push %ebp <== NOT EXECUTED 10d5bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d5bf: 53 push %ebx <== NOT EXECUTED 10d5c0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d5c3: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( !_States_Is_dormant( the_thread->current_state ) ) { 10d5c6: f6 43 10 01 testb $0x1,0x10(%ebx) <== NOT EXECUTED 10d5ca: 74 08 je 10d5d4 <_Thread_Restart+0x18> <== NOT EXECUTED 10d5cc: 31 c0 xor %eax,%eax <== NOT EXECUTED return TRUE; } return FALSE; } 10d5ce: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d5d1: c9 leave <== NOT EXECUTED 10d5d2: c3 ret <== NOT EXECUTED 10d5d3: 90 nop <== NOT EXECUTED Thread_Entry_numeric_type numeric_argument ) { if ( !_States_Is_dormant( the_thread->current_state ) ) { _Thread_Set_transient( the_thread ); 10d5d4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d5d7: 53 push %ebx <== NOT EXECUTED 10d5d8: e8 b7 01 00 00 call 10d794 <_Thread_Set_transient> <== NOT EXECUTED _Thread_Reset( the_thread, pointer_argument, numeric_argument ); 10d5dd: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10d5e0: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10d5e3: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d5e6: 53 push %ebx <== NOT EXECUTED 10d5e7: e8 48 34 00 00 call 110a34 <_Thread_Reset> <== NOT EXECUTED _Thread_Load_environment( the_thread ); 10d5ec: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10d5ef: e8 1c 31 00 00 call 110710 <_Thread_Load_environment> <== NOT EXECUTED _Thread_Ready( the_thread ); 10d5f4: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10d5f7: e8 98 33 00 00 call 110994 <_Thread_Ready> <== NOT EXECUTED _User_extensions_Thread_restart( the_thread ); 10d5fc: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10d5ff: e8 94 06 00 00 call 10dc98 <_User_extensions_Thread_restart> <== NOT EXECUTED if ( _Thread_Is_executing ( the_thread ) ) 10d604: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d607: 3b 1d 5c 2e 12 00 cmp 0x122e5c,%ebx <== NOT EXECUTED 10d60d: 74 09 je 10d618 <_Thread_Restart+0x5c> <== NOT EXECUTED 10d60f: b0 01 mov $0x1,%al <== NOT EXECUTED return TRUE; } return FALSE; } 10d611: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d614: c9 leave <== NOT EXECUTED 10d615: c3 ret <== NOT EXECUTED 10d616: 66 90 xchg %ax,%ax <== NOT EXECUTED * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @param[in] alignment the required alignment 10d618: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax <== NOT EXECUTED 10d61e: 85 c0 test %eax,%eax <== NOT EXECUTED 10d620: 74 12 je 10d634 <_Thread_Restart+0x78> <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10d622: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d625: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax <== NOT EXECUTED 10d62b: 50 push %eax <== NOT EXECUTED 10d62c: e8 2d 0a 00 00 call 10e05e <_CPU_Context_restore_fp> <== NOT EXECUTED 10d631: 83 c4 10 add $0x10,%esp <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, 10d634: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d637: a1 5c 2e 12 00 mov 0x122e5c,%eax <== NOT EXECUTED 10d63c: 05 d4 00 00 00 add $0xd4,%eax <== NOT EXECUTED 10d641: 50 push %eax <== NOT EXECUTED 10d642: e8 06 0a 00 00 call 10e04d <_CPU_Context_restore> <== NOT EXECUTED 10d647: b0 01 mov $0x1,%al <== NOT EXECUTED 10d649: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d64c: eb 80 jmp 10d5ce <_Thread_Restart+0x12> <== NOT EXECUTED 0010e08c <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 10e08c: 55 push %ebp <== NOT EXECUTED 10e08d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e08f: 53 push %ebx <== NOT EXECUTED 10e090: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10e093: 8a 45 0c mov 0xc(%ebp),%al <== NOT EXECUTED ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10e096: 9c pushf <== NOT EXECUTED 10e097: fa cli <== NOT EXECUTED 10e098: 5b pop %ebx <== NOT EXECUTED if ( force == TRUE ) 10e099: 84 c0 test %al,%al <== NOT EXECUTED 10e09b: 74 13 je 10e0b0 <_Thread_Resume+0x24> <== NOT EXECUTED the_thread->suspend_count = 0; 10e09d: c7 41 70 00 00 00 00 movl $0x0,0x70(%ecx) <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { _ISR_Enable( level ); return; } current_state = the_thread->current_state; 10e0a4: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED if ( current_state & STATES_SUSPENDED ) { 10e0a7: a8 02 test $0x2,%al <== NOT EXECUTED 10e0a9: 75 15 jne 10e0c0 <_Thread_Resume+0x34> <== NOT EXECUTED _Context_Switch_necessary = TRUE; } } } _ISR_Enable( level ); 10e0ab: 53 push %ebx <== NOT EXECUTED 10e0ac: 9d popf <== NOT EXECUTED } 10e0ad: 5b pop %ebx <== NOT EXECUTED 10e0ae: c9 leave <== NOT EXECUTED 10e0af: c3 ret <== NOT EXECUTED _ISR_Disable( level ); if ( force == TRUE ) the_thread->suspend_count = 0; else the_thread->suspend_count--; 10e0b0: 8b 41 70 mov 0x70(%ecx),%eax <== NOT EXECUTED 10e0b3: 48 dec %eax <== NOT EXECUTED 10e0b4: 89 41 70 mov %eax,0x70(%ecx) <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 10e0b7: 85 c0 test %eax,%eax <== NOT EXECUTED 10e0b9: 74 e9 je 10e0a4 <_Thread_Resume+0x18> <== NOT EXECUTED _ISR_Enable( level ); 10e0bb: 53 push %ebx <== NOT EXECUTED 10e0bc: 9d popf <== NOT EXECUTED } } } _ISR_Enable( level ); } 10e0bd: 5b pop %ebx <== NOT EXECUTED 10e0be: c9 leave <== NOT EXECUTED 10e0bf: c3 ret <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10e0c0: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED return; } current_state = the_thread->current_state; if ( current_state & STATES_SUSPENDED ) { current_state = 10e0c3: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); if ( _States_Is_ready( current_state ) ) { 10e0c6: 85 c0 test %eax,%eax <== NOT EXECUTED 10e0c8: 75 e1 jne 10e0ab <_Thread_Resume+0x1f> <== NOT EXECUTED * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of * @param[in] size points to a user area to return the size in 10e0ca: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10e0d0: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10e0d7: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10e0da: 66 a1 90 b8 12 00 mov 0x12b890,%ax <== NOT EXECUTED 10e0e0: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10e0e6: 66 a3 90 b8 12 00 mov %ax,0x12b890 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10e0ec: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10e0f2: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10e0f5: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10e0f7: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10e0fa: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10e0fd: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10e0ff: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10e102: 53 push %ebx <== NOT EXECUTED 10e103: 9d popf <== NOT EXECUTED 10e104: fa cli <== NOT EXECUTED if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10e105: 8b 51 14 mov 0x14(%ecx),%edx <== NOT EXECUTED 10e108: a1 68 b8 12 00 mov 0x12b868,%eax <== NOT EXECUTED 10e10d: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10e110: 73 99 jae 10e0ab <_Thread_Resume+0x1f> <== NOT EXECUTED _Thread_Heir = the_thread; 10e112: 89 0d 68 b8 12 00 mov %ecx,0x12b868 <== NOT EXECUTED if ( _Thread_Executing->is_preemptible || 10e118: a1 9c b8 12 00 mov 0x12b89c,%eax <== NOT EXECUTED 10e11d: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10e121: 74 0d je 10e130 <_Thread_Resume+0xa4> <== NOT EXECUTED the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10e123: c6 05 ac b8 12 00 01 movb $0x1,0x12b8ac <== NOT EXECUTED 10e12a: e9 7c ff ff ff jmp 10e0ab <_Thread_Resume+0x1f> <== NOT EXECUTED 10e12f: 90 nop <== NOT EXECUTED _ISR_Flash( level ); if ( the_thread->current_priority < _Thread_Heir->current_priority ) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 10e130: 85 d2 test %edx,%edx <== NOT EXECUTED 10e132: 0f 85 73 ff ff ff jne 10e0ab <_Thread_Resume+0x1f> <== NOT EXECUTED 10e138: eb e9 jmp 10e123 <_Thread_Resume+0x97> <== NOT EXECUTED 0010cb94 <_Thread_Set_priority>: void _Thread_Set_priority( Thread_Control *the_thread, Priority_Control new_priority ) { 10cb94: 55 push %ebp <== NOT EXECUTED 10cb95: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb97: 56 push %esi <== NOT EXECUTED 10cb98: 53 push %ebx <== NOT EXECUTED 10cb99: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10cb9c: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED the_thread->current_priority = new_priority; 10cb9f: 89 53 14 mov %edx,0x14(%ebx) <== NOT EXECUTED the_thread->ready = &_Thread_Ready_chain[ new_priority ]; 10cba2: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10cba5: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10cba8: 03 05 80 f7 11 00 add 0x11f780,%eax <== NOT EXECUTED 10cbae: 89 83 8c 00 00 00 mov %eax,0x8c(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon * @param[in] source is a user specified integer which may be used to * indicate where in the application this was invoked from * @param[in] do_dump is set to TRUE if errors should be printed * @return TRUE if the test passed fine, FALSE otherwise. */ 10cbb4: 89 d1 mov %edx,%ecx <== NOT EXECUTED 10cbb6: c1 e9 04 shr $0x4,%ecx <== NOT EXECUTED bool _Protected_heap_Walk( Heap_Control *the_heap, int source, 10cbb9: 0f b7 c9 movzwl %cx,%ecx <== NOT EXECUTED 10cbbc: 8d 84 09 00 f9 11 00 lea 0x11f900(%ecx,%ecx,1),%eax <== NOT EXECUTED 10cbc3: 89 83 90 00 00 00 mov %eax,0x90(%ebx) <== NOT EXECUTED bool do_dump ); 10cbc9: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10cbce: 89 c6 mov %eax,%esi <== NOT EXECUTED 10cbd0: d3 e6 shl %cl,%esi <== NOT EXECUTED 10cbd2: 89 f1 mov %esi,%ecx <== NOT EXECUTED /** 10cbd4: 66 89 b3 94 00 00 00 mov %si,0x94(%ebx) <== NOT EXECUTED * This routine walks the heap and tots up the free and allocated 10cbdb: f7 d1 not %ecx <== NOT EXECUTED 10cbdd: 66 89 8b 98 00 00 00 mov %cx,0x98(%ebx) <== NOT EXECUTED * sizes. * 10cbe4: 83 e2 0f and $0xf,%edx <== NOT EXECUTED 10cbe7: 88 d1 mov %dl,%cl <== NOT EXECUTED 10cbe9: d3 e0 shl %cl,%eax <== NOT EXECUTED * @param[in] the_heap pointer to heap header 10cbeb: 66 89 83 96 00 00 00 mov %ax,0x96(%ebx) <== NOT EXECUTED * @param[in] the_info pointer to a status information area 10cbf2: f7 d0 not %eax <== NOT EXECUTED 10cbf4: 66 89 83 9a 00 00 00 mov %ax,0x9a(%ebx) <== NOT EXECUTED _Priority_Initialize_information( &the_thread->Priority_map, new_priority ); } 10cbfb: 5b pop %ebx <== NOT EXECUTED 10cbfc: 5e pop %esi <== NOT EXECUTED 10cbfd: c9 leave <== NOT EXECUTED 10cbfe: c3 ret <== NOT EXECUTED 0010cc00 <_Thread_Set_state>: void _Thread_Set_state( Thread_Control *the_thread, States_Control state ) { 10cc00: 55 push %ebp <== NOT EXECUTED 10cc01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cc03: 56 push %esi <== NOT EXECUTED 10cc04: 53 push %ebx <== NOT EXECUTED 10cc05: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10cc08: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Chain_Control *ready; ready = the_thread->ready; 10cc0b: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx <== NOT EXECUTED _ISR_Disable( level ); 10cc11: 9c pushf <== NOT EXECUTED 10cc12: fa cli <== NOT EXECUTED 10cc13: 5e pop %esi <== NOT EXECUTED if ( !_States_Is_ready( the_thread->current_state ) ) { 10cc14: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10cc17: 85 c0 test %eax,%eax <== NOT EXECUTED 10cc19: 75 2d jne 10cc48 <_Thread_Set_state+0x48> <== NOT EXECUTED _States_Set( state, the_thread->current_state ); _ISR_Enable( level ); return; } the_thread->current_state = state; 10cc1b: 89 4b 10 mov %ecx,0x10(%ebx) <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10cc1e: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10cc20: 3b 42 08 cmp 0x8(%edx),%eax <== NOT EXECUTED 10cc23: 74 2f je 10cc54 <_Thread_Set_state+0x54> <== NOT EXECUTED 10cc25: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10cc27: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10cc2a: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10cc2d: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Priority_Remove_from_bit_map( &the_thread->Priority_map ); } else _Chain_Extract_unprotected( &the_thread->Object.Node ); _ISR_Flash( level ); 10cc2f: 56 push %esi <== NOT EXECUTED 10cc30: 9d popf <== NOT EXECUTED 10cc31: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) 10cc32: 3b 1d 48 f8 11 00 cmp 0x11f848,%ebx <== NOT EXECUTED 10cc38: 74 62 je 10cc9c <_Thread_Set_state+0x9c> <== NOT EXECUTED _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) 10cc3a: 3b 1d 7c f8 11 00 cmp 0x11f87c,%ebx <== NOT EXECUTED 10cc40: 74 4e je 10cc90 <_Thread_Set_state+0x90> <== NOT EXECUTED _Context_Switch_necessary = TRUE; _ISR_Enable( level ); 10cc42: 56 push %esi <== NOT EXECUTED 10cc43: 9d popf <== NOT EXECUTED } 10cc44: 5b pop %ebx <== NOT EXECUTED 10cc45: 5e pop %esi <== NOT EXECUTED 10cc46: c9 leave <== NOT EXECUTED 10cc47: c3 ret <== NOT EXECUTED Chain_Control *ready; ready = the_thread->ready; _ISR_Disable( level ); if ( !_States_Is_ready( the_thread->current_state ) ) { the_thread->current_state = 10cc48: 09 c1 or %eax,%ecx <== NOT EXECUTED 10cc4a: 89 4b 10 mov %ecx,0x10(%ebx) <== NOT EXECUTED _States_Set( state, the_thread->current_state ); _ISR_Enable( level ); 10cc4d: 56 push %esi <== NOT EXECUTED 10cc4e: 9d popf <== NOT EXECUTED if ( _Thread_Is_executing( the_thread ) ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10cc4f: 5b pop %ebx <== NOT EXECUTED 10cc50: 5e pop %esi <== NOT EXECUTED 10cc51: c9 leave <== NOT EXECUTED 10cc52: c3 ret <== NOT EXECUTED 10cc53: 90 nop <== NOT EXECUTED 10cc54: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10cc57: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10cc59: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10cc60: 89 52 08 mov %edx,0x8(%edx) <== NOT EXECUTED /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * * @param[in] the_heap is the heap to operate upon 10cc63: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10cc69: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10cc70: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10cc73: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10cc77: 75 b6 jne 10cc2f <_Thread_Set_state+0x2f> <== NOT EXECUTED * to be resized 10cc79: 66 a1 70 f8 11 00 mov 0x11f870,%ax <== NOT EXECUTED 10cc7f: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10cc85: 66 a3 70 f8 11 00 mov %ax,0x11f870 <== NOT EXECUTED 10cc8b: eb a2 jmp 10cc2f <_Thread_Set_state+0x2f> <== NOT EXECUTED 10cc8d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) _Context_Switch_necessary = TRUE; 10cc90: c6 05 8c f8 11 00 01 movb $0x1,0x11f88c <== NOT EXECUTED 10cc97: eb a9 jmp 10cc42 <_Thread_Set_state+0x42> <== NOT EXECUTED 10cc99: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10cc9c: 66 8b 0d 70 f8 11 00 mov 0x11f870,%cx <== NOT EXECUTED 10cca3: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cca5: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cca7: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10ccab: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10ccae: 66 8b 8c 00 00 f9 11 mov 0x11f900(%eax,%eax,1),%cx <== NOT EXECUTED 10ccb5: 00 <== NOT EXECUTED 10ccb6: 66 0f bc d1 bsf %cx,%dx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10ccba: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10ccbd: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10ccc0: 01 d0 add %edx,%eax <== NOT EXECUTED 10ccc2: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10ccc5: 8b 15 80 f7 11 00 mov 0x11f780,%edx <== NOT EXECUTED 10cccb: 8b 04 82 mov (%edx,%eax,4),%eax <== NOT EXECUTED 10ccce: a3 48 f8 11 00 mov %eax,0x11f848 <== NOT EXECUTED 10ccd3: e9 62 ff ff ff jmp 10cc3a <_Thread_Set_state+0x3a> <== NOT EXECUTED 0010ccd8 <_Thread_Set_transient>: */ void _Thread_Set_transient( Thread_Control *the_thread ) { 10ccd8: 55 push %ebp <== NOT EXECUTED 10ccd9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ccdb: 56 push %esi <== NOT EXECUTED 10ccdc: 53 push %ebx <== NOT EXECUTED 10ccdd: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; uint32_t old_state; Chain_Control *ready; ready = the_thread->ready; 10cce0: 8b 8b 8c 00 00 00 mov 0x8c(%ebx),%ecx <== NOT EXECUTED _ISR_Disable( level ); 10cce6: 9c pushf <== NOT EXECUTED 10cce7: fa cli <== NOT EXECUTED 10cce8: 5e pop %esi <== NOT EXECUTED old_state = the_thread->current_state; 10cce9: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED the_thread->current_state = _States_Set( STATES_TRANSIENT, old_state ); 10ccec: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ccee: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 10ccf1: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED if ( _States_Is_ready( old_state ) ) { 10ccf4: 85 d2 test %edx,%edx <== NOT EXECUTED 10ccf6: 75 11 jne 10cd09 <_Thread_Set_transient+0x31> <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10ccf8: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10ccfa: 3b 41 08 cmp 0x8(%ecx),%eax <== NOT EXECUTED 10ccfd: 74 11 je 10cd10 <_Thread_Set_transient+0x38> <== NOT EXECUTED 10ccff: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10cd01: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10cd04: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10cd07: 89 10 mov %edx,(%eax) <== NOT EXECUTED } else _Chain_Extract_unprotected( &the_thread->Object.Node ); } _ISR_Enable( level ); 10cd09: 56 push %esi <== NOT EXECUTED 10cd0a: 9d popf <== NOT EXECUTED } 10cd0b: 5b pop %ebx <== NOT EXECUTED 10cd0c: 5e pop %esi <== NOT EXECUTED 10cd0d: c9 leave <== NOT EXECUTED 10cd0e: c3 ret <== NOT EXECUTED 10cd0f: 90 nop <== NOT EXECUTED 10cd10: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10cd13: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10cd15: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10cd1c: 89 49 08 mov %ecx,0x8(%ecx) <== NOT EXECUTED /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * * @param[in] the_heap is the heap to operate upon 10cd1f: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10cd25: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10cd2c: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10cd2f: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10cd33: 75 d4 jne 10cd09 <_Thread_Set_transient+0x31> <== NOT EXECUTED * to be resized 10cd35: 66 a1 70 f8 11 00 mov 0x11f870,%ax <== NOT EXECUTED 10cd3b: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10cd41: 66 a3 70 f8 11 00 mov %ax,0x11f870 <== NOT EXECUTED 10cd47: eb c0 jmp 10cd09 <_Thread_Set_transient+0x31> <== NOT EXECUTED 0010cd4c <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 10cd4c: 55 push %ebp <== NOT EXECUTED 10cd4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cd4f: 53 push %ebx <== NOT EXECUTED 10cd50: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10cd53: a1 d0 b1 11 00 mov 0x11b1d0,%eax <== NOT EXECUTED 10cd58: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10cd5b: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10cd5d: 73 02 jae 10cd61 <_Thread_Stack_Allocate+0x15> <== NOT EXECUTED 10cd5f: 89 c3 mov %eax,%ebx <== 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 ( _Configuration_Table->stack_allocate_hook ) { 10cd61: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10cd66: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED 10cd69: 85 c0 test %eax,%eax <== NOT EXECUTED 10cd6b: 74 33 je 10cda0 <_Thread_Stack_Allocate+0x54> <== NOT EXECUTED stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size ); 10cd6d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cd70: 53 push %ebx <== NOT EXECUTED 10cd71: ff d0 call *%eax <== NOT EXECUTED 10cd73: 89 c2 mov %eax,%edx <== NOT EXECUTED 10cd75: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 10cd78: 85 d2 test %edx,%edx <== NOT EXECUTED 10cd7a: 74 10 je 10cd8c <_Thread_Stack_Allocate+0x40> <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; 10cd7c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cd7f: 89 90 d0 00 00 00 mov %edx,0xd0(%eax) <== NOT EXECUTED return the_stack_size; } 10cd85: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10cd87: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cd8a: c9 leave <== NOT EXECUTED 10cd8b: c3 ret <== NOT EXECUTED the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 10cd8c: 31 db xor %ebx,%ebx <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; 10cd8e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cd91: 89 90 d0 00 00 00 mov %edx,0xd0(%eax) <== NOT EXECUTED return the_stack_size; } 10cd97: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10cd99: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cd9c: c9 leave <== NOT EXECUTED 10cd9d: c3 ret <== NOT EXECUTED 10cd9e: 66 90 xchg %ax,%ax <== NOT EXECUTED * get and keep the stack adjust factor, the stack alignment, and * the context initialization sequence in sync. */ the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); 10cda0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cda3: 53 push %ebx <== NOT EXECUTED 10cda4: e8 d7 06 00 00 call 10d480 <_Workspace_Allocate> <== NOT EXECUTED 10cda9: 89 c2 mov %eax,%edx <== NOT EXECUTED 10cdab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cdae: eb c8 jmp 10cd78 <_Thread_Stack_Allocate+0x2c> <== NOT EXECUTED 0010cdb0 <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 10cdb0: 55 push %ebp <== NOT EXECUTED 10cdb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cdb3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED /* * If the API provided the stack space, then don't free it. */ if ( !the_thread->Start.core_allocated_stack ) 10cdb6: 80 ba c0 00 00 00 00 cmpb $0x0,0xc0(%edx) <== NOT EXECUTED 10cdbd: 74 19 je 10cdd8 <_Thread_Stack_Free+0x28> <== NOT EXECUTED * Call ONLY the CPU table stack free hook, or the * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ if ( _Configuration_Table->stack_free_hook ) 10cdbf: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10cdc4: 8b 48 24 mov 0x24(%eax),%ecx <== NOT EXECUTED 10cdc7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10cdc9: 74 11 je 10cddc <_Thread_Stack_Free+0x2c> <== NOT EXECUTED (*_Configuration_Table->stack_free_hook)( 10cdcb: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax <== NOT EXECUTED 10cdd1: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10cdd4: c9 leave <== NOT EXECUTED * the RTEMS workspace free. This is so the free * routine properly matches the allocation of the stack. */ if ( _Configuration_Table->stack_free_hook ) (*_Configuration_Table->stack_free_hook)( 10cdd5: ff e1 jmp *%ecx <== NOT EXECUTED 10cdd7: 90 nop <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10cdd8: c9 leave <== NOT EXECUTED 10cdd9: c3 ret <== NOT EXECUTED 10cdda: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( _Configuration_Table->stack_free_hook ) (*_Configuration_Table->stack_free_hook)( the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); 10cddc: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax <== NOT EXECUTED 10cde2: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10cde5: c9 leave <== NOT EXECUTED if ( _Configuration_Table->stack_free_hook ) (*_Configuration_Table->stack_free_hook)( the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); 10cde6: e9 7d 06 00 00 jmp 10d468 <_Workspace_Free> <== NOT EXECUTED 0010ce48 <_Thread_Start>: Thread_Start_types the_prototype, void *entry_point, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10ce48: 55 push %ebp <== NOT EXECUTED 10ce49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ce4b: 53 push %ebx <== NOT EXECUTED 10ce4c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10ce4f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( _States_Is_dormant( the_thread->current_state ) ) { 10ce52: f6 43 10 01 testb $0x1,0x10(%ebx) <== NOT EXECUTED 10ce56: 75 08 jne 10ce60 <_Thread_Start+0x18> <== NOT EXECUTED 10ce58: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; } return false; } 10ce5a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ce5d: c9 leave <== NOT EXECUTED 10ce5e: c3 ret <== NOT EXECUTED 10ce5f: 90 nop <== NOT EXECUTED Thread_Entry_numeric_type numeric_argument ) { if ( _States_Is_dormant( the_thread->current_state ) ) { the_thread->Start.entry_point = (Thread_Entry) entry_point; 10ce60: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10ce63: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx) <== NOT EXECUTED the_thread->Start.prototype = the_prototype; 10ce69: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ce6c: 89 83 a0 00 00 00 mov %eax,0xa0(%ebx) <== NOT EXECUTED the_thread->Start.pointer_argument = pointer_argument; 10ce72: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10ce75: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) <== NOT EXECUTED the_thread->Start.numeric_argument = numeric_argument; 10ce7b: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10ce7e: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) <== NOT EXECUTED _Thread_Load_environment( the_thread ); 10ce84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ce87: 53 push %ebx <== NOT EXECUTED 10ce88: e8 eb 2c 00 00 call 10fb78 <_Thread_Load_environment> <== NOT EXECUTED _Thread_Ready( the_thread ); 10ce8d: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10ce90: e8 67 2f 00 00 call 10fdfc <_Thread_Ready> <== NOT EXECUTED _User_extensions_Thread_start( the_thread ); 10ce95: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10ce98: e8 3f 03 00 00 call 10d1dc <_User_extensions_Thread_start> <== NOT EXECUTED 10ce9d: b0 01 mov $0x1,%al <== NOT EXECUTED 10ce9f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return true; } return false; } 10cea2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cea5: c9 leave <== NOT EXECUTED 10cea6: c3 ret <== NOT EXECUTED 0010cdec <_Thread_Start_multitasking>: * ready chain * select heir */ void _Thread_Start_multitasking( void ) { 10cdec: 55 push %ebp <== NOT EXECUTED 10cded: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cdef: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10cdf2: c7 05 84 f9 11 00 03 movl $0x3,0x11f984 <== NOT EXECUTED 10cdf9: 00 00 00 <== NOT EXECUTED * the system is shut down. */ _System_state_Set( SYSTEM_STATE_UP ); _Context_Switch_necessary = FALSE; 10cdfc: c6 05 8c f8 11 00 00 movb $0x0,0x11f88c <== NOT EXECUTED _Thread_Executing = _Thread_Heir; 10ce03: a1 48 f8 11 00 mov 0x11f848,%eax <== NOT EXECUTED 10ce08: a3 7c f8 11 00 mov %eax,0x11f87c <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) /* * don't need to worry about saving BSP's floating point state */ if ( _Thread_Heir->fp_context != NULL ) 10ce0d: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx <== NOT EXECUTED 10ce13: 85 d2 test %edx,%edx <== NOT EXECUTED 10ce15: 74 16 je 10ce2d <_Thread_Start_multitasking+0x41> <== NOT EXECUTED _Context_Restore_fp( &_Thread_Heir->fp_context ); 10ce17: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ce1a: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10ce1f: 50 push %eax <== NOT EXECUTED 10ce20: e8 39 07 00 00 call 10d55e <_CPU_Context_restore_fp> <== NOT EXECUTED 10ce25: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ce28: a1 48 f8 11 00 mov 0x11f848,%eax <== NOT EXECUTED #endif _Context_Switch( &_Thread_BSP_context, &_Thread_Heir->Registers ); 10ce2d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ce30: 05 d4 00 00 00 add $0xd4,%eax <== NOT EXECUTED 10ce35: 50 push %eax <== NOT EXECUTED 10ce36: 68 a0 f7 11 00 push $0x11f7a0 <== NOT EXECUTED 10ce3b: e8 e0 06 00 00 call 10d520 <_CPU_Context_switch> <== NOT EXECUTED 10ce40: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10ce43: c9 leave <== NOT EXECUTED 10ce44: c3 ret <== NOT EXECUTED 0010e450 <_Thread_Suspend>: */ void _Thread_Suspend( Thread_Control *the_thread ) { 10e450: 55 push %ebp <== NOT EXECUTED 10e451: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e453: 56 push %esi <== NOT EXECUTED 10e454: 53 push %ebx <== NOT EXECUTED 10e455: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Chain_Control *ready; ready = the_thread->ready; 10e458: 8b 91 8c 00 00 00 mov 0x8c(%ecx),%edx <== NOT EXECUTED _ISR_Disable( level ); 10e45e: 9c pushf <== NOT EXECUTED 10e45f: fa cli <== NOT EXECUTED 10e460: 5b pop %ebx <== NOT EXECUTED the_thread->suspend_count++; 10e461: ff 41 70 incl 0x70(%ecx) <== NOT EXECUTED if ( !_States_Is_ready( the_thread->current_state ) ) { 10e464: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED 10e467: 85 c0 test %eax,%eax <== NOT EXECUTED 10e469: 75 31 jne 10e49c <_Thread_Suspend+0x4c> <== NOT EXECUTED _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); return; } the_thread->current_state = STATES_SUSPENDED; 10e46b: c7 41 10 02 00 00 00 movl $0x2,0x10(%ecx) <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10e472: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10e474: 3b 42 08 cmp 0x8(%edx),%eax <== NOT EXECUTED 10e477: 74 2f je 10e4a8 <_Thread_Suspend+0x58> <== NOT EXECUTED 10e479: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10e47b: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10e47e: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10e481: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Priority_Remove_from_bit_map( &the_thread->Priority_map ); } else _Chain_Extract_unprotected( &the_thread->Object.Node ); _ISR_Flash( level ); 10e483: 53 push %ebx <== NOT EXECUTED 10e484: 9d popf <== NOT EXECUTED 10e485: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) 10e486: 3b 0d 68 b8 12 00 cmp 0x12b868,%ecx <== NOT EXECUTED 10e48c: 74 62 je 10e4f0 <_Thread_Suspend+0xa0> <== NOT EXECUTED _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) 10e48e: 3b 0d 9c b8 12 00 cmp 0x12b89c,%ecx <== NOT EXECUTED 10e494: 74 4e je 10e4e4 <_Thread_Suspend+0x94> <== NOT EXECUTED _Context_Switch_necessary = TRUE; _ISR_Enable( level ); 10e496: 53 push %ebx <== NOT EXECUTED 10e497: 9d popf <== NOT EXECUTED } 10e498: 5b pop %ebx <== NOT EXECUTED 10e499: 5e pop %esi <== NOT EXECUTED 10e49a: c9 leave <== NOT EXECUTED 10e49b: c3 ret <== NOT EXECUTED ready = the_thread->ready; _ISR_Disable( level ); the_thread->suspend_count++; if ( !_States_Is_ready( the_thread->current_state ) ) { the_thread->current_state = 10e49c: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 10e49f: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); 10e4a2: 53 push %ebx <== NOT EXECUTED 10e4a3: 9d popf <== NOT EXECUTED if ( _Thread_Is_executing( the_thread ) ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10e4a4: 5b pop %ebx <== NOT EXECUTED 10e4a5: 5e pop %esi <== NOT EXECUTED 10e4a6: c9 leave <== NOT EXECUTED 10e4a7: c3 ret <== NOT EXECUTED 10e4a8: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10e4ab: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10e4ad: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10e4b4: 89 52 08 mov %edx,0x8(%edx) <== NOT EXECUTED /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * * @param[in] the_heap is the heap to operate upon 10e4b7: 8b 81 90 00 00 00 mov 0x90(%ecx),%eax <== NOT EXECUTED 10e4bd: 66 8b 91 9a 00 00 00 mov 0x9a(%ecx),%dx <== NOT EXECUTED 10e4c4: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10e4c7: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10e4cb: 75 b6 jne 10e483 <_Thread_Suspend+0x33> <== NOT EXECUTED * to be resized 10e4cd: 66 a1 90 b8 12 00 mov 0x12b890,%ax <== NOT EXECUTED 10e4d3: 23 81 98 00 00 00 and 0x98(%ecx),%eax <== NOT EXECUTED 10e4d9: 66 a3 90 b8 12 00 mov %ax,0x12b890 <== NOT EXECUTED 10e4df: eb a2 jmp 10e483 <_Thread_Suspend+0x33> <== NOT EXECUTED 10e4e1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) _Context_Switch_necessary = TRUE; 10e4e4: c6 05 ac b8 12 00 01 movb $0x1,0x12b8ac <== NOT EXECUTED 10e4eb: eb a9 jmp 10e496 <_Thread_Suspend+0x46> <== NOT EXECUTED 10e4ed: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10e4f0: 66 8b 35 90 b8 12 00 mov 0x12b890,%si <== NOT EXECUTED 10e4f7: 31 d2 xor %edx,%edx <== NOT EXECUTED 10e4f9: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e4fb: 66 0f bc c6 bsf %si,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10e4ff: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10e502: 66 8b b4 00 20 b9 12 mov 0x12b920(%eax,%eax,1),%si <== NOT EXECUTED 10e509: 00 <== NOT EXECUTED 10e50a: 66 0f bc d6 bsf %si,%dx <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10e50e: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10e511: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10e514: 01 d0 add %edx,%eax <== NOT EXECUTED 10e516: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10e519: 8b 15 a0 b7 12 00 mov 0x12b7a0,%edx <== NOT EXECUTED 10e51f: 8b 04 82 mov (%edx,%eax,4),%eax <== NOT EXECUTED 10e522: a3 68 b8 12 00 mov %eax,0x12b868 <== NOT EXECUTED 10e527: e9 62 ff ff ff jmp 10e48e <_Thread_Suspend+0x3e> <== NOT EXECUTED 0010cea8 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10cea8: 55 push %ebp <== NOT EXECUTED 10cea9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ceab: 53 push %ebx <== NOT EXECUTED 10ceac: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 10ceaf: 8b 1d 7c f8 11 00 mov 0x11f87c,%ebx <== NOT EXECUTED /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10ceb5: 80 7b 76 00 cmpb $0x0,0x76(%ebx) <== NOT EXECUTED 10ceb9: 74 19 je 10ced4 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED return; if ( !_States_Is_ready( executing->current_state ) ) 10cebb: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10cebe: 85 c0 test %eax,%eax <== NOT EXECUTED 10cec0: 75 12 jne 10ced4 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10cec2: 8b 43 7c mov 0x7c(%ebx),%eax <== NOT EXECUTED 10cec5: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10cec8: 72 0a jb 10ced4 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED 10ceca: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10cecd: 76 29 jbe 10cef8 <_Thread_Tickle_timeslice+0x50> <== NOT EXECUTED 10cecf: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10ced2: 74 08 je 10cedc <_Thread_Tickle_timeslice+0x34> <== NOT EXECUTED case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) (*executing->budget_callout)( executing ); break; } } 10ced4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ced7: c9 leave <== NOT EXECUTED 10ced8: c3 ret <== NOT EXECUTED 10ced9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; } break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10cedc: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 10cedf: 48 dec %eax <== NOT EXECUTED 10cee0: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10cee3: 85 c0 test %eax,%eax <== NOT EXECUTED 10cee5: 75 ed jne 10ced4 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED (*executing->budget_callout)( executing ); 10cee7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ceea: 53 push %ebx <== NOT EXECUTED 10ceeb: ff 93 80 00 00 00 call *0x80(%ebx) <== NOT EXECUTED 10cef1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cef4: eb de jmp 10ced4 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED 10cef6: 66 90 xchg %ax,%ax <== NOT EXECUTED case THREAD_CPU_BUDGET_ALGORITHM_NONE: break; case THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE: case THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE: if ( (int)(--executing->cpu_time_budget) <= 0 ) { 10cef8: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 10cefb: 48 dec %eax <== NOT EXECUTED 10cefc: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10ceff: 85 c0 test %eax,%eax <== NOT EXECUTED 10cf01: 7f d1 jg 10ced4 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED _Thread_Reset_timeslice(); 10cf03: e8 94 2f 00 00 call 10fe9c <_Thread_Reset_timeslice> <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10cf08: a1 84 f7 11 00 mov 0x11f784,%eax <== NOT EXECUTED 10cf0d: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10cf10: eb c2 jmp 10ced4 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED 0010cf14 <_Thread_Yield_processor>: * ready chain * select heir */ void _Thread_Yield_processor( void ) { 10cf14: 55 push %ebp <== NOT EXECUTED 10cf15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cf17: 56 push %esi <== NOT EXECUTED 10cf18: 53 push %ebx <== NOT EXECUTED ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10cf19: 8b 0d 7c f8 11 00 mov 0x11f87c,%ecx <== NOT EXECUTED ready = executing->ready; 10cf1f: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx <== NOT EXECUTED _ISR_Disable( level ); 10cf25: 9c pushf <== NOT EXECUTED 10cf26: fa cli <== NOT EXECUTED 10cf27: 5e pop %esi <== NOT EXECUTED if ( !_Chain_Has_only_one_node( ready ) ) { 10cf28: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10cf2a: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10cf2d: 74 35 je 10cf64 <_Thread_Yield_processor+0x50> <== NOT EXECUTED 10cf2f: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10cf31: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10cf34: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10cf37: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10cf39: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10cf3c: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10cf3e: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10cf41: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED 10cf44: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10cf46: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 10cf49: 56 push %esi <== NOT EXECUTED 10cf4a: 9d popf <== NOT EXECUTED 10cf4b: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( executing ) ) 10cf4c: 3b 0d 48 f8 11 00 cmp 0x11f848,%ecx <== NOT EXECUTED 10cf52: 74 1c je 10cf70 <_Thread_Yield_processor+0x5c> <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) _Context_Switch_necessary = TRUE; 10cf54: c6 05 8c f8 11 00 01 movb $0x1,0x11f88c <== NOT EXECUTED _ISR_Enable( level ); 10cf5b: 56 push %esi <== NOT EXECUTED 10cf5c: 9d popf <== NOT EXECUTED } 10cf5d: 5b pop %ebx <== NOT EXECUTED 10cf5e: 5e pop %esi <== NOT EXECUTED 10cf5f: c9 leave <== NOT EXECUTED 10cf60: c3 ret <== NOT EXECUTED 10cf61: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) 10cf64: 3b 0d 48 f8 11 00 cmp 0x11f848,%ecx <== NOT EXECUTED 10cf6a: 75 e8 jne 10cf54 <_Thread_Yield_processor+0x40> <== NOT EXECUTED 10cf6c: eb ed jmp 10cf5b <_Thread_Yield_processor+0x47> <== NOT EXECUTED 10cf6e: 66 90 xchg %ax,%ax <== NOT EXECUTED _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; 10cf70: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10cf72: a3 48 f8 11 00 mov %eax,0x11f848 <== NOT EXECUTED 10cf77: eb db jmp 10cf54 <_Thread_Yield_processor+0x40> <== NOT EXECUTED 0010be24 <_Thread_blocking_operation_Cancel>: void _Thread_blocking_operation_Cancel( Thread_blocking_operation_States sync_state, Thread_Control *the_thread, ISR_Level level ) { 10be24: 55 push %ebp <== NOT EXECUTED 10be25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10be27: 53 push %ebx <== NOT EXECUTED 10be28: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10be2b: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10be2e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED #endif /* * The thread is not waiting on anything after this completes. */ the_thread->Wait.queue = NULL; 10be31: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED /* * If the sync state is timed out, this is very likely not needed. * But better safe than sorry when it comes to critical sections. */ if ( _Watchdog_Is_active( &the_thread->Timer ) ) { 10be38: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10be3c: 74 16 je 10be54 <_Thread_blocking_operation_Cancel+0x30> <== NOT EXECUTED _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); (void) _Watchdog_Remove( &the_thread->Timer ); } else _ISR_Enable( level ); 10be3e: 50 push %eax <== NOT EXECUTED 10be3f: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10be40: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10be47: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10be4a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10be4d: c9 leave <== NOT EXECUTED 10be4e: e9 51 01 00 00 jmp 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 10be53: 90 nop <== NOT EXECUTED * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 10be54: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED * If the sync state is timed out, this is very likely not needed. * But better safe than sorry when it comes to critical sections. */ if ( _Watchdog_Is_active( &the_thread->Timer ) ) { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10be5b: 50 push %eax <== NOT EXECUTED 10be5c: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10be5d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10be60: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10be63: 50 push %eax <== NOT EXECUTED 10be64: e8 23 15 00 00 call 10d38c <_Watchdog_Remove> <== NOT EXECUTED 10be69: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10be6c: eb d2 jmp 10be40 <_Thread_blocking_operation_Cancel+0x1c> <== NOT EXECUTED 0010c6d0 <_Thread_queue_Dequeue>: */ Thread_Control *_Thread_queue_Dequeue( Thread_queue_Control *the_thread_queue ) { 10c6d0: 55 push %ebp <== NOT EXECUTED 10c6d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c6d3: 53 push %ebx <== NOT EXECUTED 10c6d4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10c6d7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Thread_Control *(*dequeue_p)( Thread_queue_Control * ); Thread_Control *the_thread; ISR_Level level; Thread_blocking_operation_States sync_state; if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10c6da: 83 7b 34 01 cmpl $0x1,0x34(%ebx) <== NOT EXECUTED 10c6de: 74 20 je 10c700 <_Thread_queue_Dequeue+0x30> <== NOT EXECUTED 10c6e0: b8 00 fc 10 00 mov $0x10fc00,%eax <== NOT EXECUTED dequeue_p = _Thread_queue_Dequeue_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ dequeue_p = _Thread_queue_Dequeue_fifo; the_thread = (*dequeue_p)( the_thread_queue ); 10c6e5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c6e8: 53 push %ebx <== NOT EXECUTED 10c6e9: ff d0 call *%eax <== NOT EXECUTED 10c6eb: 89 c2 mov %eax,%edx <== NOT EXECUTED _ISR_Disable( level ); 10c6ed: 9c pushf <== NOT EXECUTED 10c6ee: fa cli <== NOT EXECUTED 10c6ef: 59 pop %ecx <== NOT EXECUTED if ( !the_thread ) { 10c6f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c6f3: 85 c0 test %eax,%eax <== NOT EXECUTED 10c6f5: 74 11 je 10c708 <_Thread_queue_Dequeue+0x38> <== NOT EXECUTED (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; the_thread = _Thread_Executing; } } _ISR_Enable( level ); 10c6f7: 51 push %ecx <== NOT EXECUTED 10c6f8: 9d popf <== NOT EXECUTED return the_thread; } 10c6f9: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c6fb: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c6fe: c9 leave <== NOT EXECUTED 10c6ff: c3 ret <== NOT EXECUTED Thread_Control *(*dequeue_p)( Thread_queue_Control * ); Thread_Control *the_thread; ISR_Level level; Thread_blocking_operation_States sync_state; if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10c700: b8 20 c7 10 00 mov $0x10c720,%eax <== NOT EXECUTED 10c705: eb de jmp 10c6e5 <_Thread_queue_Dequeue+0x15> <== NOT EXECUTED 10c707: 90 nop <== NOT EXECUTED the_thread = (*dequeue_p)( the_thread_queue ); _ISR_Disable( level ); if ( !the_thread ) { sync_state = the_thread_queue->sync_state; if ( (sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) || 10c708: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10c70b: 48 dec %eax <== NOT EXECUTED 10c70c: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10c70f: 77 e6 ja 10c6f7 <_Thread_queue_Dequeue+0x27> <== NOT EXECUTED (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 10c711: c7 43 30 03 00 00 00 movl $0x3,0x30(%ebx) <== NOT EXECUTED the_thread = _Thread_Executing; 10c718: 8b 15 7c f8 11 00 mov 0x11f87c,%edx <== NOT EXECUTED 10c71e: eb d7 jmp 10c6f7 <_Thread_queue_Dequeue+0x27> <== NOT EXECUTED 0010fc00 <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 10fc00: 55 push %ebp <== NOT EXECUTED 10fc01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fc03: 56 push %esi <== NOT EXECUTED 10fc04: 53 push %ebx <== NOT EXECUTED 10fc05: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 10fc08: 9c pushf <== NOT EXECUTED 10fc09: fa cli <== NOT EXECUTED 10fc0a: 5e pop %esi <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10fc0b: 8b 11 mov (%ecx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 10fc0d: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10fc10: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10fc12: 74 62 je 10fc76 <_Thread_queue_Dequeue_fifo+0x76> <== NOT EXECUTED 10fc14: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10fc16: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10fc18: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread = (Thread_Control *) 10fc1b: 89 d3 mov %edx,%ebx <== NOT EXECUTED _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo ); the_thread->Wait.queue = NULL; 10fc1d: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10fc24: 83 7a 50 02 cmpl $0x2,0x50(%edx) <== NOT EXECUTED 10fc28: 74 1e je 10fc48 <_Thread_queue_Dequeue_fifo+0x48> <== NOT EXECUTED _ISR_Enable( level ); 10fc2a: 56 push %esi <== NOT EXECUTED 10fc2b: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10fc2c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10fc2f: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10fc34: 52 push %edx <== NOT EXECUTED 10fc35: e8 6a c3 ff ff call 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 10fc3a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return the_thread; } _ISR_Enable( level ); return NULL; } 10fc3d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10fc3f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10fc42: 5b pop %ebx <== NOT EXECUTED 10fc43: 5e pop %esi <== NOT EXECUTED 10fc44: c9 leave <== NOT EXECUTED 10fc45: c3 ret <== NOT EXECUTED 10fc46: 66 90 xchg %ax,%ax <== NOT EXECUTED * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 10fc48: c7 42 50 03 00 00 00 movl $0x3,0x50(%edx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10fc4f: 56 push %esi <== NOT EXECUTED 10fc50: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10fc51: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fc54: 8d 42 48 lea 0x48(%edx),%eax <== NOT EXECUTED 10fc57: 50 push %eax <== NOT EXECUTED 10fc58: e8 2f d7 ff ff call 10d38c <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10fc5d: 58 pop %eax <== NOT EXECUTED 10fc5e: 5a pop %edx <== NOT EXECUTED 10fc5f: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10fc64: 53 push %ebx <== NOT EXECUTED 10fc65: e8 3a c3 ff ff call 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 10fc6a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return the_thread; } _ISR_Enable( level ); return NULL; } 10fc6d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10fc6f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10fc72: 5b pop %ebx <== NOT EXECUTED 10fc73: 5e pop %esi <== NOT EXECUTED 10fc74: c9 leave <== NOT EXECUTED 10fc75: c3 ret <== NOT EXECUTED #endif return the_thread; } _ISR_Enable( level ); 10fc76: 56 push %esi <== NOT EXECUTED 10fc77: 9d popf <== NOT EXECUTED 10fc78: 31 db xor %ebx,%ebx <== NOT EXECUTED 10fc7a: eb c1 jmp 10fc3d <_Thread_queue_Dequeue_fifo+0x3d> <== NOT EXECUTED 0010c720 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 10c720: 55 push %ebp <== NOT EXECUTED 10c721: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c723: 57 push %edi <== NOT EXECUTED 10c724: 56 push %esi <== NOT EXECUTED 10c725: 53 push %ebx <== NOT EXECUTED 10c726: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c729: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *new_second_node; Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); 10c72c: 9c pushf <== NOT EXECUTED 10c72d: fa cli <== NOT EXECUTED 10c72e: 5f pop %edi <== NOT EXECUTED 10c72f: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c731: 31 c9 xor %ecx,%ecx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10c733: 8b 1c 0e mov (%esi,%ecx,1),%ebx <== NOT EXECUTED for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { 10c736: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10c739: 8d 44 86 04 lea 0x4(%esi,%eax,4),%eax <== NOT EXECUTED 10c73d: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10c73f: 75 1f jne 10c760 <_Thread_queue_Dequeue_priority+0x40> <== NOT EXECUTED Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 10c741: 42 inc %edx <== NOT EXECUTED 10c742: 83 c1 0c add $0xc,%ecx <== NOT EXECUTED Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 10c745: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10c748: 75 e9 jne 10c733 <_Thread_queue_Dequeue_priority+0x13> <== NOT EXECUTED } /* * We did not find a thread to unblock. */ _ISR_Enable( level ); 10c74a: 57 push %edi <== NOT EXECUTED 10c74b: 9d popf <== NOT EXECUTED 10c74c: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp) <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 10c753: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10c756: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c759: 5b pop %ebx <== NOT EXECUTED 10c75a: 5e pop %esi <== NOT EXECUTED 10c75b: 5f pop %edi <== NOT EXECUTED 10c75c: c9 leave <== NOT EXECUTED 10c75d: c3 ret <== NOT EXECUTED 10c75e: 66 90 xchg %ax,%ax <== NOT EXECUTED _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 *) 10c760: 89 5d e8 mov %ebx,-0x18(%ebp) <== NOT EXECUTED */ _ISR_Enable( level ); return NULL; dequeue: the_thread->Wait.queue = NULL; 10c763: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED new_first_node = the_thread->Wait.Block2n.first; 10c76a: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; 10c76d: 8b 33 mov (%ebx),%esi <== NOT EXECUTED previous_node = the_thread->Object.Node.previous; 10c76f: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10c772: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10c775: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10c777: 0f 84 85 00 00 00 je 10c802 <_Thread_queue_Dequeue_priority+0xe2> <== NOT EXECUTED last_node = the_thread->Wait.Block2n.last; 10c77d: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10c780: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED new_second_node = new_first_node->next; 10c783: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10c785: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED previous_node->next = new_first_node; 10c788: 89 11 mov %edx,(%ecx) <== NOT EXECUTED next_node->previous = new_first_node; 10c78a: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED new_first_node->next = next_node; 10c78d: 89 32 mov %esi,(%edx) <== NOT EXECUTED new_first_node->previous = previous_node; 10c78f: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10c792: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10c795: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10c798: 74 1a je 10c7b4 <_Thread_queue_Dequeue_priority+0x94> <== NOT EXECUTED /* > two threads on 2-n */ new_second_node->previous = 10c79a: 8d 42 38 lea 0x38(%edx),%eax <== NOT EXECUTED 10c79d: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 10c7a0: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 10c7a3: 89 4a 38 mov %ecx,0x38(%edx) <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 10c7a6: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10c7a9: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10c7ac: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10c7af: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10c7b2: 89 02 mov %eax,(%edx) <== NOT EXECUTED } else { previous_node->next = next_node; next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10c7b4: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10c7b8: 74 1e je 10c7d8 <_Thread_queue_Dequeue_priority+0xb8> <== NOT EXECUTED _ISR_Enable( level ); 10c7ba: 57 push %edi <== NOT EXECUTED 10c7bb: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10c7bc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c7bf: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10c7c4: 53 push %ebx <== NOT EXECUTED 10c7c5: e8 da f7 ff ff call 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 10c7ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 10c7cd: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10c7d0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c7d3: 5b pop %ebx <== NOT EXECUTED 10c7d4: 5e pop %esi <== NOT EXECUTED 10c7d5: 5f pop %edi <== NOT EXECUTED 10c7d6: c9 leave <== NOT EXECUTED 10c7d7: c3 ret <== NOT EXECUTED * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 10c7d8: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10c7df: 57 push %edi <== NOT EXECUTED 10c7e0: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10c7e1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c7e4: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10c7e7: 50 push %eax <== NOT EXECUTED 10c7e8: e8 9f 0b 00 00 call 10d38c <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10c7ed: 58 pop %eax <== NOT EXECUTED 10c7ee: 5a pop %edx <== NOT EXECUTED 10c7ef: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10c7f4: 53 push %ebx <== NOT EXECUTED 10c7f5: e8 aa f7 ff ff call 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 10c7fa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c7fd: e9 51 ff ff ff jmp 10c753 <_Thread_queue_Dequeue_priority+0x33> <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); } } else { previous_node->next = next_node; 10c802: 89 31 mov %esi,(%ecx) <== NOT EXECUTED next_node->previous = previous_node; 10c804: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED 10c807: eb ab jmp 10c7b4 <_Thread_queue_Dequeue_priority+0x94> <== NOT EXECUTED 0010fc7c <_Thread_queue_Enqueue_fifo>: Thread_blocking_operation_States _Thread_queue_Enqueue_fifo ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 10fc7c: 55 push %ebp <== NOT EXECUTED 10fc7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fc7f: 56 push %esi <== NOT EXECUTED 10fc80: 53 push %ebx <== NOT EXECUTED 10fc81: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10fc84: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Thread_blocking_operation_States sync_state; ISR_Level level; _ISR_Disable( level ); 10fc87: 9c pushf <== NOT EXECUTED 10fc88: fa cli <== NOT EXECUTED 10fc89: 5e pop %esi <== NOT EXECUTED sync_state = the_thread_queue->sync_state; 10fc8a: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10fc8d: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) { 10fc94: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED 10fc97: 74 0b je 10fca4 <_Thread_queue_Enqueue_fifo+0x28> <== NOT EXECUTED * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; 10fc99: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10fc9c: 89 30 mov %esi,(%eax) <== NOT EXECUTED return sync_state; } 10fc9e: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10fca0: 5b pop %ebx <== NOT EXECUTED 10fca1: 5e pop %esi <== NOT EXECUTED 10fca2: c9 leave <== NOT EXECUTED 10fca3: c3 ret <== NOT EXECUTED 10fca4: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10fca7: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10fca9: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10fcac: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED 10fcaf: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10fcb1: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) { _Chain_Append_unprotected( &the_thread_queue->Queues.Fifo, &the_thread->Object.Node ); the_thread->Wait.queue = the_thread_queue; 10fcb4: 89 53 44 mov %edx,0x44(%ebx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; _ISR_Enable( level ); 10fcb7: 56 push %esi <== NOT EXECUTED 10fcb8: 9d popf <== NOT EXECUTED * * WARNING! Returning with interrupts disabled! */ *level_p = level; return sync_state; } 10fcb9: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10fcbb: 5b pop %ebx <== NOT EXECUTED 10fcbc: 5e pop %esi <== NOT EXECUTED 10fcbd: c9 leave <== NOT EXECUTED 10fcbe: c3 ret <== NOT EXECUTED 0010c8a4 <_Thread_queue_Enqueue_priority>: Thread_blocking_operation_States _Thread_queue_Enqueue_priority ( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, ISR_Level *level_p ) { 10c8a4: 55 push %ebp <== NOT EXECUTED 10c8a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c8a7: 57 push %edi <== NOT EXECUTED 10c8a8: 56 push %esi <== NOT EXECUTED 10c8a9: 53 push %ebx <== NOT EXECUTED 10c8aa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c8ad: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c8b0: 83 c0 3c add $0x3c,%eax <== NOT EXECUTED 10c8b3: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c8b6: 89 42 38 mov %eax,0x38(%edx) <== NOT EXECUTED 10c8b9: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx) <== NOT EXECUTED 10c8c0: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c8c2: 83 c0 38 add $0x38,%eax <== NOT EXECUTED 10c8c5: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 10c8c8: 8b 5a 14 mov 0x14(%edx),%ebx <== NOT EXECUTED extern "C" { #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. 10c8cb: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c8cd: c1 e8 06 shr $0x6,%eax <== NOT EXECUTED header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; block_state = the_thread_queue->state; 10c8d0: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c8d3: 8b 49 38 mov 0x38(%ecx),%ecx <== NOT EXECUTED 10c8d6: 89 4d f0 mov %ecx,-0x10(%ebp) <== NOT EXECUTED if ( _Thread_queue_Is_reverse_search( priority ) ) 10c8d9: f6 c3 20 test $0x20,%bl <== NOT EXECUTED 10c8dc: 75 66 jne 10c944 <_Thread_queue_Enqueue_priority+0xa0> <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10c8de: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10c8e1: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10c8e4: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c8e7: 8d 7c 02 04 lea 0x4(%edx,%eax,1),%edi <== NOT EXECUTED goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; 10c8eb: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 10c8ee: 9c pushf <== NOT EXECUTED 10c8ef: fa cli <== NOT EXECUTED 10c8f0: 5e pop %esi <== NOT EXECUTED search_thread = (Thread_Control *) header->first; 10c8f1: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10c8f4: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c8f7: 8b 14 08 mov (%eax,%ecx,1),%edx <== NOT EXECUTED while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c8fa: 39 fa cmp %edi,%edx <== NOT EXECUTED 10c8fc: 75 1b jne 10c919 <_Thread_queue_Enqueue_priority+0x75> <== NOT EXECUTED 10c8fe: e9 1a 01 00 00 jmp 10ca1d <_Thread_queue_Enqueue_priority+0x179> <== NOT EXECUTED 10c903: 90 nop <== NOT EXECUTED break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10c904: 56 push %esi <== NOT EXECUTED 10c905: 9d popf <== NOT EXECUTED 10c906: fa cli <== NOT EXECUTED if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c907: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10c90a: 85 42 10 test %eax,0x10(%edx) <== NOT EXECUTED 10c90d: 0f 84 ad 00 00 00 je 10c9c0 <_Thread_queue_Enqueue_priority+0x11c> <== NOT EXECUTED _ISR_Enable( level ); goto restart_forward_search; } search_thread = 10c913: 8b 12 mov (%edx),%edx <== NOT EXECUTED restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c915: 39 fa cmp %edi,%edx <== NOT EXECUTED 10c917: 74 07 je 10c920 <_Thread_queue_Enqueue_priority+0x7c> <== NOT EXECUTED search_priority = search_thread->current_priority; 10c919: 8b 4a 14 mov 0x14(%edx),%ecx <== NOT EXECUTED if ( priority <= search_priority ) 10c91c: 39 cb cmp %ecx,%ebx <== NOT EXECUTED 10c91e: 77 e4 ja 10c904 <_Thread_queue_Enqueue_priority+0x60> <== NOT EXECUTED restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c920: 89 d7 mov %edx,%edi <== NOT EXECUTED } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10c922: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c925: 83 78 30 01 cmpl $0x1,0x30(%eax) <== NOT EXECUTED 10c929: 0f 84 99 00 00 00 je 10c9c8 <_Thread_queue_Enqueue_priority+0x124> <== NOT EXECUTED * For example, the blocking thread could have been given * the mutex by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ *level_p = level; 10c92f: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10c932: 89 30 mov %esi,(%eax) <== NOT EXECUTED return the_thread_queue->sync_state; 10c934: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c937: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED } 10c93a: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c93d: 5b pop %ebx <== NOT EXECUTED 10c93e: 5e pop %esi <== NOT EXECUTED 10c93f: 5f pop %edi <== NOT EXECUTED 10c940: c9 leave <== NOT EXECUTED 10c941: c3 ret <== NOT EXECUTED 10c942: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node->previous = previous_node; previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 10c944: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10c947: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c94a: 8d 0c 82 lea (%edx,%eax,4),%ecx <== NOT EXECUTED restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 10c94d: 8d 79 08 lea 0x8(%ecx),%edi <== NOT EXECUTED 10c950: 89 7d ec mov %edi,-0x14(%ebp) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 10c953: 0f b6 05 d4 b1 11 00 movzbl 0x11b1d4,%eax <== NOT EXECUTED 10c95a: 40 inc %eax <== NOT EXECUTED _ISR_Disable( level ); 10c95b: 9c pushf <== NOT EXECUTED 10c95c: fa cli <== NOT EXECUTED 10c95d: 5e pop %esi <== NOT EXECUTED search_thread = (Thread_Control *) header->last; 10c95e: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 10c961: 8b 17 mov (%edi),%edx <== NOT EXECUTED while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c963: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 10c965: 75 17 jne 10c97e <_Thread_queue_Enqueue_priority+0xda> <== NOT EXECUTED 10c967: eb 1c jmp 10c985 <_Thread_queue_Enqueue_priority+0xe1> <== NOT EXECUTED 10c969: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10c96c: 56 push %esi <== NOT EXECUTED 10c96d: 9d popf <== NOT EXECUTED 10c96e: fa cli <== NOT EXECUTED if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c96f: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 10c972: 85 7a 10 test %edi,0x10(%edx) <== NOT EXECUTED 10c975: 74 45 je 10c9bc <_Thread_queue_Enqueue_priority+0x118> <== NOT EXECUTED _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) 10c977: 8b 52 04 mov 0x4(%edx),%edx <== NOT EXECUTED restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c97a: 39 ca cmp %ecx,%edx <== NOT EXECUTED 10c97c: 74 07 je 10c985 <_Thread_queue_Enqueue_priority+0xe1> <== NOT EXECUTED search_priority = search_thread->current_priority; 10c97e: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED if ( priority >= search_priority ) 10c981: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10c983: 72 e7 jb 10c96c <_Thread_queue_Enqueue_priority+0xc8> <== NOT EXECUTED restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c985: 89 d7 mov %edx,%edi <== NOT EXECUTED } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10c987: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c98a: 83 79 30 01 cmpl $0x1,0x30(%ecx) <== NOT EXECUTED 10c98e: 75 9f jne 10c92f <_Thread_queue_Enqueue_priority+0x8b> <== NOT EXECUTED THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c990: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) <== NOT EXECUTED if ( priority == search_priority ) 10c997: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10c999: 74 5d je 10c9f8 <_Thread_queue_Enqueue_priority+0x154> <== NOT EXECUTED goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10c99b: 8b 02 mov (%edx),%eax <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10c99d: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10c9a0: 89 07 mov %eax,(%edi) <== NOT EXECUTED the_node->previous = search_node; 10c9a2: 89 57 04 mov %edx,0x4(%edi) <== NOT EXECUTED search_node->next = the_node; 10c9a5: 89 3a mov %edi,(%edx) <== NOT EXECUTED next_node->previous = the_node; 10c9a7: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10c9aa: 89 4f 44 mov %ecx,0x44(%edi) <== NOT EXECUTED _ISR_Enable( level ); 10c9ad: 56 push %esi <== NOT EXECUTED 10c9ae: 9d popf <== NOT EXECUTED 10c9af: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10c9b4: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c9b7: 5b pop %ebx <== NOT EXECUTED 10c9b8: 5e pop %esi <== NOT EXECUTED 10c9b9: 5f pop %edi <== NOT EXECUTED 10c9ba: c9 leave <== NOT EXECUTED 10c9bb: c3 ret <== NOT EXECUTED if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 10c9bc: 56 push %esi <== NOT EXECUTED 10c9bd: 9d popf <== NOT EXECUTED 10c9be: eb 93 jmp 10c953 <_Thread_queue_Enqueue_priority+0xaf> <== NOT EXECUTED if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 10c9c0: 56 push %esi <== NOT EXECUTED 10c9c1: 9d popf <== NOT EXECUTED 10c9c2: e9 27 ff ff ff jmp 10c8ee <_Thread_queue_Enqueue_priority+0x4a> <== NOT EXECUTED 10c9c7: 90 nop <== NOT EXECUTED if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c9c8: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED if ( priority == search_priority ) 10c9cf: 39 cb cmp %ecx,%ebx <== NOT EXECUTED 10c9d1: 74 25 je 10c9f8 <_Thread_queue_Enqueue_priority+0x154> <== NOT EXECUTED goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10c9d3: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c9d6: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10c9d9: 89 11 mov %edx,(%ecx) <== NOT EXECUTED the_node->previous = previous_node; 10c9db: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED previous_node->next = the_node; 10c9de: 89 08 mov %ecx,(%eax) <== NOT EXECUTED search_node->previous = the_node; 10c9e0: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10c9e3: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10c9e6: 89 79 44 mov %edi,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10c9e9: 56 push %esi <== NOT EXECUTED 10c9ea: 9d popf <== NOT EXECUTED 10c9eb: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10c9f0: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c9f3: 5b pop %ebx <== NOT EXECUTED 10c9f4: 5e pop %esi <== NOT EXECUTED 10c9f5: 5f pop %edi <== NOT EXECUTED 10c9f6: c9 leave <== NOT EXECUTED 10c9f7: c3 ret <== NOT EXECUTED 10c9f8: 8d 47 3c lea 0x3c(%edi),%eax <== NOT EXECUTED _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; equal_priority: /* add at end of priority group */ search_node = _Chain_Tail( &search_thread->Wait.Block2n ); previous_node = search_node->previous; 10c9fb: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c9fe: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10ca01: 89 01 mov %eax,(%ecx) <== NOT EXECUTED the_node->previous = previous_node; 10ca03: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED previous_node->next = the_node; 10ca06: 89 0a mov %ecx,(%edx) <== NOT EXECUTED search_node->previous = the_node; 10ca08: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10ca0b: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10ca0e: 89 79 44 mov %edi,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10ca11: 56 push %esi <== NOT EXECUTED 10ca12: 9d popf <== NOT EXECUTED 10ca13: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10ca18: e9 1d ff ff ff jmp 10c93a <_Thread_queue_Enqueue_priority+0x96> <== NOT EXECUTED restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10ca1d: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 10ca22: e9 fb fe ff ff jmp 10c922 <_Thread_queue_Enqueue_priority+0x7e> <== NOT EXECUTED 0010c80c <_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 ) { 10c80c: 55 push %ebp <== NOT EXECUTED 10c80d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c80f: 57 push %edi <== NOT EXECUTED 10c810: 56 push %esi <== NOT EXECUTED 10c811: 53 push %ebx <== NOT EXECUTED 10c812: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 10c815: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10c818: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Thread_queue_Control *, Thread_Control *, ISR_Level * ); the_thread = _Thread_Executing; 10c81b: 8b 1d 7c f8 11 00 mov 0x11f87c,%ebx <== NOT EXECUTED else #endif /* * Set the blocking state for this thread queue in the thread. */ _Thread_Set_state( the_thread, the_thread_queue->state ); 10c821: ff 76 38 pushl 0x38(%esi) <== NOT EXECUTED 10c824: 53 push %ebx <== NOT EXECUTED 10c825: e8 d6 03 00 00 call 10cc00 <_Thread_Set_state> <== NOT EXECUTED /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { 10c82a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c82d: 85 ff test %edi,%edi <== NOT EXECUTED 10c82f: 75 33 jne 10c864 <_Thread_queue_Enqueue_with_handler+0x58> <== NOT EXECUTED } /* * Now enqueue the thread per the discipline for this thread queue. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10c831: 83 7e 34 01 cmpl $0x1,0x34(%esi) <== NOT EXECUTED 10c835: 74 64 je 10c89b <_Thread_queue_Enqueue_with_handler+0x8f> <== NOT EXECUTED 10c837: ba 7c fc 10 00 mov $0x10fc7c,%edx <== NOT EXECUTED enqueue_p = _Thread_queue_Enqueue_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ enqueue_p = _Thread_queue_Enqueue_fifo; sync_state = (*enqueue_p)( the_thread_queue, the_thread, &level ); 10c83c: 51 push %ecx <== NOT EXECUTED 10c83d: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c840: 50 push %eax <== NOT EXECUTED 10c841: 53 push %ebx <== NOT EXECUTED 10c842: 56 push %esi <== NOT EXECUTED 10c843: ff d2 call *%edx <== NOT EXECUTED if ( sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 10c845: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c848: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10c84b: 74 0e je 10c85b <_Thread_queue_Enqueue_with_handler+0x4f> <== NOT EXECUTED _Thread_blocking_operation_Cancel( sync_state, the_thread, level ); 10c84d: 52 push %edx <== NOT EXECUTED 10c84e: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10c851: 53 push %ebx <== NOT EXECUTED 10c852: 50 push %eax <== NOT EXECUTED 10c853: e8 cc f5 ff ff call 10be24 <_Thread_blocking_operation_Cancel> <== NOT EXECUTED 10c858: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10c85b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c85e: 5b pop %ebx <== NOT EXECUTED 10c85f: 5e pop %esi <== NOT EXECUTED 10c860: 5f pop %edi <== NOT EXECUTED 10c861: c9 leave <== NOT EXECUTED 10c862: c3 ret <== NOT EXECUTED 10c863: 90 nop <== NOT EXECUTED /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { _Watchdog_Initialize( 10c864: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10c867: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10c86e: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10c871: 89 53 64 mov %edx,0x64(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10c874: 89 43 68 mov %eax,0x68(%ebx) <== NOT EXECUTED * the heap 10c877: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10c87e: 89 7b 54 mov %edi,0x54(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10c881: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c884: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10c887: 50 push %eax <== NOT EXECUTED 10c888: 68 9c f8 11 00 push $0x11f89c <== NOT EXECUTED 10c88d: e8 ca 09 00 00 call 10d25c <_Watchdog_Insert> <== NOT EXECUTED 10c892: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Now enqueue the thread per the discipline for this thread queue. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10c895: 83 7e 34 01 cmpl $0x1,0x34(%esi) <== NOT EXECUTED 10c899: 75 9c jne 10c837 <_Thread_queue_Enqueue_with_handler+0x2b> <== NOT EXECUTED 10c89b: ba a4 c8 10 00 mov $0x10c8a4,%edx <== NOT EXECUTED 10c8a0: eb 9a jmp 10c83c <_Thread_queue_Enqueue_with_handler+0x30> <== NOT EXECUTED 0010fcc0 <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10fcc0: 55 push %ebp <== NOT EXECUTED 10fcc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fcc3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10fcc6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fcc9: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED /* * Can not use indirect function pointer here since Extract priority * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10fccc: 83 78 34 01 cmpl $0x1,0x34(%eax) <== NOT EXECUTED 10fcd0: 74 0e je 10fce0 <_Thread_queue_Extract+0x20> <== NOT EXECUTED _Thread_queue_Extract_priority( the_thread_queue, the_thread ); else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 10fcd2: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 10fcd5: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10fcd8: c9 leave <== NOT EXECUTED * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) _Thread_queue_Extract_priority( the_thread_queue, the_thread ); else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); 10fcd9: e9 96 0e 00 00 jmp 110b74 <_Thread_queue_Extract_fifo> <== NOT EXECUTED 10fcde: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Can not use indirect function pointer here since Extract priority * is a macro and the underlying methods do not have the same signature. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) _Thread_queue_Extract_priority( the_thread_queue, the_thread ); 10fce0: 51 push %ecx <== NOT EXECUTED 10fce1: 6a 00 push $0x0 <== NOT EXECUTED 10fce3: 52 push %edx <== NOT EXECUTED 10fce4: 50 push %eax <== NOT EXECUTED 10fce5: e8 06 00 00 00 call 10fcf0 <_Thread_queue_Extract_priority_helper> <== NOT EXECUTED 10fcea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); } 10fced: c9 leave <== NOT EXECUTED 10fcee: c3 ret <== NOT EXECUTED 00110b74 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 110b74: 55 push %ebp <== NOT EXECUTED 110b75: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110b77: 53 push %ebx <== NOT EXECUTED 110b78: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 110b7b: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 110b7e: 9c pushf <== NOT EXECUTED 110b7f: fa cli <== NOT EXECUTED 110b80: 59 pop %ecx <== NOT EXECUTED if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 110b81: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) <== NOT EXECUTED 110b88: 74 2e je 110bb8 <_Thread_queue_Extract_fifo+0x44> <== NOT EXECUTED 110b8a: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 110b8c: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 110b8f: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 110b92: 89 10 mov %edx,(%eax) <== NOT EXECUTED return; } _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; 110b94: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 110b9b: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 110b9f: 74 1f je 110bc0 <_Thread_queue_Extract_fifo+0x4c> <== NOT EXECUTED _ISR_Enable( level ); 110ba1: 51 push %ecx <== NOT EXECUTED 110ba2: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 110ba3: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 110baa: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 110bad: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110bb0: c9 leave <== NOT EXECUTED 110bb1: e9 ee b3 ff ff jmp 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 110bb6: 66 90 xchg %ax,%ax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _ISR_Enable( level ); 110bb8: 51 push %ecx <== NOT EXECUTED 110bb9: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 110bba: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110bbd: c9 leave <== NOT EXECUTED 110bbe: c3 ret <== NOT EXECUTED 110bbf: 90 nop <== NOT EXECUTED * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 110bc0: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 110bc7: 51 push %ecx <== NOT EXECUTED 110bc8: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 110bc9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110bcc: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 110bcf: 50 push %eax <== NOT EXECUTED 110bd0: e8 b7 c7 ff ff call 10d38c <_Watchdog_Remove> <== NOT EXECUTED 110bd5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110bd8: eb c9 jmp 110ba3 <_Thread_queue_Extract_fifo+0x2f> <== NOT EXECUTED 0010fcf0 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, bool requeuing ) { 10fcf0: 55 push %ebp <== NOT EXECUTED 10fcf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fcf3: 57 push %edi <== NOT EXECUTED 10fcf4: 56 push %esi <== NOT EXECUTED 10fcf5: 53 push %ebx <== NOT EXECUTED 10fcf6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fcf9: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10fcfc: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10fcff: 88 45 eb mov %al,-0x15(%ebp) <== NOT EXECUTED Chain_Node *new_first_node; Chain_Node *new_second_node; Chain_Node *last_node; the_node = (Chain_Node *) the_thread; _ISR_Disable( level ); 10fd02: 9c pushf <== NOT EXECUTED 10fd03: fa cli <== NOT EXECUTED 10fd04: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10fd07: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) <== NOT EXECUTED 10fd0e: 74 68 je 10fd78 <_Thread_queue_Extract_priority_helper+0x88> <== NOT EXECUTED /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; 10fd10: 8b 33 mov (%ebx),%esi <== NOT EXECUTED previous_node = the_node->previous; 10fd12: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10fd15: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10fd18: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10fd1b: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10fd1d: 74 71 je 10fd90 <_Thread_queue_Extract_priority_helper+0xa0> <== NOT EXECUTED new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; last_node = the_thread->Wait.Block2n.last; 10fd1f: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10fd22: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED new_second_node = new_first_node->next; 10fd25: 8b 3a mov (%edx),%edi <== NOT EXECUTED previous_node->next = new_first_node; 10fd27: 89 11 mov %edx,(%ecx) <== NOT EXECUTED next_node->previous = new_first_node; 10fd29: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED new_first_node->next = next_node; 10fd2c: 89 32 mov %esi,(%edx) <== NOT EXECUTED new_first_node->previous = previous_node; 10fd2e: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10fd31: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10fd34: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10fd37: 74 17 je 10fd50 <_Thread_queue_Extract_priority_helper+0x60> <== NOT EXECUTED /* > two threads on 2-n */ new_second_node->previous = 10fd39: 8d 42 38 lea 0x38(%edx),%eax <== NOT EXECUTED 10fd3c: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 10fd3f: 89 7a 38 mov %edi,0x38(%edx) <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 10fd42: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10fd45: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10fd48: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10fd4b: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10fd4e: 89 02 mov %eax,(%edx) <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 10fd50: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) <== NOT EXECUTED 10fd54: 75 2e jne 10fd84 <_Thread_queue_Extract_priority_helper+0x94> <== NOT EXECUTED _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10fd56: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10fd5a: 74 3c je 10fd98 <_Thread_queue_Extract_priority_helper+0xa8> <== NOT EXECUTED _ISR_Enable( level ); 10fd5c: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10fd5f: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10fd60: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10fd67: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10fd6a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fd6d: 5b pop %ebx <== NOT EXECUTED 10fd6e: 5e pop %esi <== NOT EXECUTED 10fd6f: 5f pop %edi <== NOT EXECUTED 10fd70: c9 leave <== NOT EXECUTED 10fd71: e9 2e c2 ff ff jmp 10bfa4 <_Thread_Clear_state> <== NOT EXECUTED 10fd76: 66 90 xchg %ax,%ax <== NOT EXECUTED 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 ); 10fd78: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10fd7b: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10fd7c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fd7f: 5b pop %ebx <== NOT EXECUTED 10fd80: 5e pop %esi <== NOT EXECUTED 10fd81: 5f pop %edi <== NOT EXECUTED 10fd82: c9 leave <== NOT EXECUTED 10fd83: c3 ret <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { _ISR_Enable( level ); 10fd84: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10fd87: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10fd88: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fd8b: 5b pop %ebx <== NOT EXECUTED 10fd8c: 5e pop %esi <== NOT EXECUTED 10fd8d: 5f pop %edi <== NOT EXECUTED 10fd8e: c9 leave <== NOT EXECUTED 10fd8f: c3 ret <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); } } else { previous_node->next = next_node; 10fd90: 89 31 mov %esi,(%ecx) <== NOT EXECUTED next_node->previous = previous_node; 10fd92: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED 10fd95: eb b9 jmp 10fd50 <_Thread_queue_Extract_priority_helper+0x60> <== NOT EXECUTED 10fd97: 90 nop <== NOT EXECUTED * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 10fd98: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10fd9f: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10fda2: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10fda3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fda6: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10fda9: 50 push %eax <== NOT EXECUTED 10fdaa: e8 dd d5 ff ff call 10d38c <_Watchdog_Remove> <== NOT EXECUTED 10fdaf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fdb2: eb ac jmp 10fd60 <_Thread_queue_Extract_priority_helper+0x70> <== NOT EXECUTED 0010ca28 <_Thread_queue_Extract_with_proxy>: */ bool _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 10ca28: 55 push %ebp <== NOT EXECUTED 10ca29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca2b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ca2e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED States_Control state; state = the_thread->current_state; if ( _States_Is_waiting_on_thread_queue( state ) ) { 10ca31: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax) <== NOT EXECUTED 10ca38: 75 06 jne 10ca40 <_Thread_queue_Extract_with_proxy+0x18> <== NOT EXECUTED 10ca3a: 31 c0 xor %eax,%eax <== NOT EXECUTED _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); return TRUE; } return FALSE; } 10ca3c: c9 leave <== NOT EXECUTED 10ca3d: c3 ret <== NOT EXECUTED 10ca3e: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( proxy_extract_callout ) (*proxy_extract_callout)( the_thread ); } #endif _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10ca40: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ca43: 50 push %eax <== NOT EXECUTED 10ca44: ff 70 44 pushl 0x44(%eax) <== NOT EXECUTED 10ca47: e8 74 32 00 00 call 10fcc0 <_Thread_queue_Extract> <== NOT EXECUTED 10ca4c: b0 01 mov $0x1,%al <== NOT EXECUTED 10ca4e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return TRUE; } return FALSE; } 10ca51: c9 leave <== NOT EXECUTED 10ca52: c3 ret <== NOT EXECUTED 0010eb0c <_Thread_queue_First>: */ Thread_Control *_Thread_queue_First( Thread_queue_Control *the_thread_queue ) { 10eb0c: 55 push %ebp <== NOT EXECUTED 10eb0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eb0f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED Thread_Control * (*first_p)(Thread_queue_Control *); if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10eb12: 83 78 34 01 cmpl $0x1,0x34(%eax) <== NOT EXECUTED 10eb16: 74 0c je 10eb24 <_Thread_queue_First+0x18> <== NOT EXECUTED 10eb18: b9 1c 1f 11 00 mov $0x111f1c,%ecx <== NOT EXECUTED first_p = _Thread_queue_First_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; return (*first_p)( the_thread_queue ); 10eb1d: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10eb20: c9 leave <== NOT EXECUTED if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) first_p = _Thread_queue_First_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; return (*first_p)( the_thread_queue ); 10eb21: ff e1 jmp *%ecx <== NOT EXECUTED 10eb23: 90 nop <== NOT EXECUTED Thread_queue_Control *the_thread_queue ) { Thread_Control * (*first_p)(Thread_queue_Control *); if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) 10eb24: b9 30 eb 10 00 mov $0x10eb30,%ecx <== NOT EXECUTED first_p = _Thread_queue_First_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; return (*first_p)( the_thread_queue ); 10eb29: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10eb2c: c9 leave <== NOT EXECUTED if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) first_p = _Thread_queue_First_priority; else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ first_p = _Thread_queue_First_fifo; return (*first_p)( the_thread_queue ); 10eb2d: ff e1 jmp *%ecx <== NOT EXECUTED 00111f1c <_Thread_queue_First_fifo>: */ Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { 111f1c: 55 push %ebp <== NOT EXECUTED 111f1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111f1f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 111f22: 8b 10 mov (%eax),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) 111f24: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 111f27: 39 c2 cmp %eax,%edx <== NOT EXECUTED 111f29: 74 05 je 111f30 <_Thread_queue_First_fifo+0x14> <== NOT EXECUTED return (Thread_Control *) the_thread_queue->Queues.Fifo.first; 111f2b: 89 d0 mov %edx,%eax <== NOT EXECUTED return NULL; } 111f2d: c9 leave <== NOT EXECUTED 111f2e: c3 ret <== NOT EXECUTED 111f2f: 90 nop <== NOT EXECUTED Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) 111f30: 31 c0 xor %eax,%eax <== NOT EXECUTED return (Thread_Control *) the_thread_queue->Queues.Fifo.first; return NULL; } 111f32: c9 leave <== NOT EXECUTED 111f33: c3 ret <== NOT EXECUTED 0010eb30 <_Thread_queue_First_priority>: */ Thread_Control *_Thread_queue_First_priority ( Thread_queue_Control *the_thread_queue ) { 10eb30: 55 push %ebp <== NOT EXECUTED 10eb31: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eb33: 56 push %esi <== NOT EXECUTED 10eb34: 53 push %ebx <== NOT EXECUTED 10eb35: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10eb38: 31 d2 xor %edx,%edx <== NOT EXECUTED 10eb3a: 31 c9 xor %ecx,%ecx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10eb3c: 8b 1c 0e mov (%esi,%ecx,1),%ebx <== NOT EXECUTED uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) 10eb3f: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10eb42: 8d 44 86 04 lea 0x4(%esi,%eax,4),%eax <== NOT EXECUTED 10eb46: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10eb48: 75 12 jne 10eb5c <_Thread_queue_First_priority+0x2c> <== NOT EXECUTED { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 10eb4a: 42 inc %edx <== NOT EXECUTED 10eb4b: 83 c1 0c add $0xc,%ecx <== NOT EXECUTED ) { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 10eb4e: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10eb51: 75 e9 jne 10eb3c <_Thread_queue_First_priority+0xc> <== NOT EXECUTED 10eb53: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) return (Thread_Control *) the_thread_queue->Queues.Priority[ index ].first; } return NULL; } 10eb55: 5b pop %ebx <== NOT EXECUTED 10eb56: 5e pop %esi <== NOT EXECUTED 10eb57: c9 leave <== NOT EXECUTED 10eb58: c3 ret <== NOT EXECUTED 10eb59: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) return (Thread_Control *) 10eb5c: 89 d8 mov %ebx,%eax <== NOT EXECUTED the_thread_queue->Queues.Priority[ index ].first; } return NULL; } 10eb5e: 5b pop %ebx <== NOT EXECUTED 10eb5f: 5e pop %esi <== NOT EXECUTED 10eb60: c9 leave <== NOT EXECUTED 10eb61: c3 ret <== NOT EXECUTED 0010ca54 <_Thread_queue_Flush>: void _Thread_queue_Flush( Thread_queue_Control *the_thread_queue, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 10ca54: 55 push %ebp <== NOT EXECUTED 10ca55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca57: 56 push %esi <== NOT EXECUTED 10ca58: 53 push %ebx <== NOT EXECUTED 10ca59: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10ca5c: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10ca5f: eb 06 jmp 10ca67 <_Thread_queue_Flush+0x13> <== NOT EXECUTED 10ca61: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; 10ca64: 89 58 34 mov %ebx,0x34(%eax) <== NOT EXECUTED uint32_t status ) { Thread_Control *the_thread; while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) { 10ca67: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ca6a: 56 push %esi <== NOT EXECUTED 10ca6b: e8 60 fc ff ff call 10c6d0 <_Thread_queue_Dequeue> <== NOT EXECUTED 10ca70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ca73: 85 c0 test %eax,%eax <== NOT EXECUTED 10ca75: 75 ed jne 10ca64 <_Thread_queue_Flush+0x10> <== NOT EXECUTED ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; } } 10ca77: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ca7a: 5b pop %ebx <== NOT EXECUTED 10ca7b: 5e pop %esi <== NOT EXECUTED 10ca7c: c9 leave <== NOT EXECUTED 10ca7d: c3 ret <== NOT EXECUTED 0010ca80 <_Thread_queue_Initialize>: Thread_queue_Control *the_thread_queue, Thread_queue_Disciplines the_discipline, States_Control state, uint32_t timeout_status ) { 10ca80: 55 push %ebp <== NOT EXECUTED 10ca81: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca83: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ca86: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED the_thread_queue->state = state; 10ca89: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10ca8c: 89 51 38 mov %edx,0x38(%ecx) <== NOT EXECUTED the_thread_queue->discipline = the_discipline; 10ca8f: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED the_thread_queue->timeout_status = timeout_status; 10ca92: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10ca95: 89 51 3c mov %edx,0x3c(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10ca98: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) <== NOT EXECUTED if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10ca9f: 48 dec %eax <== NOT EXECUTED 10caa0: 74 12 je 10cab4 <_Thread_queue_Initialize+0x34> <== NOT EXECUTED 10caa2: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10caa5: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10caa7: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10caae: 89 49 08 mov %ecx,0x8(%ecx) <== NOT EXECUTED _Chain_Initialize_empty( &the_thread_queue->Queues.Priority[index] ); } else { /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Chain_Initialize_empty( &the_thread_queue->Queues.Fifo ); } } 10cab1: c9 leave <== NOT EXECUTED 10cab2: c3 ret <== NOT EXECUTED 10cab3: 90 nop <== NOT EXECUTED 10cab4: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10cab7: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10cab9: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10cac0: 89 49 08 mov %ecx,0x8(%ecx) <== NOT EXECUTED 10cac3: 8d 41 10 lea 0x10(%ecx),%eax <== NOT EXECUTED 10cac6: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED 10cac9: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx) <== NOT EXECUTED 10cad0: 8d 41 0c lea 0xc(%ecx),%eax <== NOT EXECUTED 10cad3: 89 41 14 mov %eax,0x14(%ecx) <== NOT EXECUTED 10cad6: 8d 41 1c lea 0x1c(%ecx),%eax <== NOT EXECUTED 10cad9: 89 41 18 mov %eax,0x18(%ecx) <== NOT EXECUTED 10cadc: c7 41 1c 00 00 00 00 movl $0x0,0x1c(%ecx) <== NOT EXECUTED 10cae3: 8d 41 18 lea 0x18(%ecx),%eax <== NOT EXECUTED 10cae6: 89 41 20 mov %eax,0x20(%ecx) <== NOT EXECUTED 10cae9: 8d 41 28 lea 0x28(%ecx),%eax <== NOT EXECUTED 10caec: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED 10caef: c7 41 28 00 00 00 00 movl $0x0,0x28(%ecx) <== NOT EXECUTED 10caf6: 8d 41 24 lea 0x24(%ecx),%eax <== NOT EXECUTED 10caf9: 89 41 2c mov %eax,0x2c(%ecx) <== NOT EXECUTED 10cafc: c9 leave <== NOT EXECUTED 10cafd: c3 ret <== NOT EXECUTED 0010fdb4 <_Thread_queue_Process_timeout>: #include void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { 10fdb4: 55 push %ebp <== NOT EXECUTED 10fdb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fdb7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10fdba: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 10fdbd: 8b 51 44 mov 0x44(%ecx),%edx <== NOT EXECUTED * If it is not satisfied, then it is "nothing happened" and * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED && 10fdc0: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10fdc3: 85 c0 test %eax,%eax <== NOT EXECUTED 10fdc5: 74 08 je 10fdcf <_Thread_queue_Process_timeout+0x1b> <== NOT EXECUTED 10fdc7: 3b 0d 7c f8 11 00 cmp 0x11f87c,%ecx <== NOT EXECUTED 10fdcd: 74 19 je 10fde8 <_Thread_queue_Process_timeout+0x34> <== NOT EXECUTED if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10fdcf: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 10fdd2: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10fdd5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10fdd8: 51 push %ecx <== NOT EXECUTED 10fdd9: ff 71 44 pushl 0x44(%ecx) <== NOT EXECUTED 10fddc: e8 df fe ff ff call 10fcc0 <_Thread_queue_Extract> <== NOT EXECUTED 10fde1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 10fde4: c9 leave <== NOT EXECUTED 10fde5: c3 ret <== NOT EXECUTED 10fde6: 66 90 xchg %ax,%ax <== NOT EXECUTED * a timeout is not allowed to occur. */ if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SYNCHRONIZED && _Thread_Is_executing( the_thread ) ) { if ( the_thread_queue->sync_state != THREAD_BLOCKING_OPERATION_SATISFIED ) { 10fde8: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10fdeb: 74 f7 je 10fde4 <_Thread_queue_Process_timeout+0x30> <== NOT EXECUTED the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10fded: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 10fdf0: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10fdf3: c7 42 30 02 00 00 00 movl $0x2,0x30(%edx) <== NOT EXECUTED } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); } } 10fdfa: c9 leave <== NOT EXECUTED 10fdfb: c3 ret <== NOT EXECUTED 0010cb00 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10cb00: 55 push %ebp <== NOT EXECUTED 10cb01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb03: 56 push %esi <== NOT EXECUTED 10cb04: 53 push %ebx <== NOT EXECUTED 10cb05: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10cb08: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue ) 10cb0b: 85 db test %ebx,%ebx <== NOT EXECUTED 10cb0d: 74 06 je 10cb15 <_Thread_queue_Requeue+0x15> <== NOT EXECUTED /* * If queueing by FIFO, there is nothing to do. This only applies to * priority blocking discipline. */ if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10cb0f: 83 7b 34 01 cmpl $0x1,0x34(%ebx) <== NOT EXECUTED 10cb13: 74 07 je 10cb1c <_Thread_queue_Requeue+0x1c> <== NOT EXECUTED _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); } _ISR_Enable( level ); } } 10cb15: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10cb18: 5b pop %ebx <== NOT EXECUTED 10cb19: 5e pop %esi <== NOT EXECUTED 10cb1a: c9 leave <== NOT EXECUTED 10cb1b: c3 ret <== NOT EXECUTED if ( the_thread_queue->discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { Thread_queue_Control *tq = the_thread_queue; ISR_Level level; ISR_Level level_ignored; _ISR_Disable( level ); 10cb1c: 9c pushf <== NOT EXECUTED 10cb1d: fa cli <== NOT EXECUTED 10cb1e: 5e pop %esi <== NOT EXECUTED if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10cb1f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10cb22: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax) <== NOT EXECUTED 10cb29: 75 09 jne 10cb34 <_Thread_queue_Requeue+0x34> <== NOT EXECUTED _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); } _ISR_Enable( level ); 10cb2b: 56 push %esi <== NOT EXECUTED 10cb2c: 9d popf <== NOT EXECUTED } } 10cb2d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10cb30: 5b pop %ebx <== NOT EXECUTED 10cb31: 5e pop %esi <== NOT EXECUTED 10cb32: c9 leave <== NOT EXECUTED 10cb33: c3 ret <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10cb34: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) <== NOT EXECUTED ISR_Level level_ignored; _ISR_Disable( level ); if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _Thread_queue_Enter_critical_section( tq ); _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); 10cb3b: 52 push %edx <== NOT EXECUTED 10cb3c: 6a 01 push $0x1 <== NOT EXECUTED 10cb3e: 50 push %eax <== NOT EXECUTED 10cb3f: 53 push %ebx <== NOT EXECUTED 10cb40: e8 ab 31 00 00 call 10fcf0 <_Thread_queue_Extract_priority_helper> <== NOT EXECUTED (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10cb45: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10cb48: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10cb4b: 50 push %eax <== NOT EXECUTED 10cb4c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10cb4f: 53 push %ebx <== NOT EXECUTED 10cb50: e8 4f fd ff ff call 10c8a4 <_Thread_queue_Enqueue_priority> <== NOT EXECUTED 10cb55: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cb58: eb d1 jmp 10cb2b <_Thread_queue_Requeue+0x2b> <== NOT EXECUTED 0010cb5c <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 10cb5c: 55 push %ebp <== NOT EXECUTED 10cb5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb5f: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10cb62: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10cb65: 50 push %eax <== NOT EXECUTED 10cb66: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cb69: e8 02 f8 ff ff call 10c370 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10cb6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cb71: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10cb74: 85 d2 test %edx,%edx <== NOT EXECUTED 10cb76: 75 17 jne 10cb8f <_Thread_queue_Timeout+0x33> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10cb78: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cb7b: 50 push %eax <== NOT EXECUTED 10cb7c: e8 33 32 00 00 call 10fdb4 <_Thread_queue_Process_timeout> <== NOT EXECUTED 10cb81: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10cb86: 48 dec %eax <== NOT EXECUTED 10cb87: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED 10cb8c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Unnest_dispatch(); break; } } 10cb8f: c9 leave <== NOT EXECUTED 10cb90: c3 ret <== NOT EXECUTED 0010f38c <_Timer_Manager_initialization>: */ void _Timer_Manager_initialization( uint32_t maximum_timers ) { 10f38c: 55 push %ebp <== NOT EXECUTED 10f38d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f38f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10f392: 6a 04 push $0x4 <== NOT EXECUTED 10f394: 6a 00 push $0x0 <== NOT EXECUTED 10f396: 6a 3c push $0x3c <== NOT EXECUTED 10f398: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f39b: 6a 02 push $0x2 <== NOT EXECUTED 10f39d: 6a 02 push $0x2 <== NOT EXECUTED 10f39f: 68 80 03 12 00 push $0x120380 <== NOT EXECUTED 10f3a4: e8 c3 c7 ff ff call 10bb6c <_Objects_Initialize_information> <== NOT EXECUTED /* * Initialize the pointer to the Timer Server TCB to NULL indicating * that task-based timer support is not initialized. */ _Timer_Server = NULL; 10f3a9: c7 05 c4 03 12 00 00 movl $0x0,0x1203c4 <== NOT EXECUTED 10f3b0: 00 00 00 <== NOT EXECUTED _Timer_Server_schedule_operation = NULL; 10f3b3: c7 05 c0 03 12 00 00 movl $0x0,0x1203c0 <== NOT EXECUTED 10f3ba: 00 00 00 <== NOT EXECUTED 10f3bd: 83 c4 20 add $0x20,%esp <== NOT EXECUTED } 10f3c0: c9 leave <== NOT EXECUTED 10f3c1: c3 ret <== NOT EXECUTED 00114c5c <_Timer_Server_body>: * @param[in] ignored is the the task argument that is ignored */ Thread _Timer_Server_body( uint32_t ignored ) { 114c5c: 55 push %ebp <== NOT EXECUTED 114c5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114c5f: 57 push %edi <== NOT EXECUTED 114c60: 56 push %esi <== NOT EXECUTED 114c61: 53 push %ebx <== NOT EXECUTED 114c62: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 114c65: 8d 7d e8 lea -0x18(%ebp),%edi <== NOT EXECUTED 114c68: 8d 75 ec lea -0x14(%ebp),%esi <== NOT EXECUTED 114c6b: 89 75 e8 mov %esi,-0x18(%ebp) <== NOT EXECUTED 114c6e: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) <== NOT EXECUTED 114c75: 89 7d f0 mov %edi,-0x10(%ebp) <== NOT EXECUTED /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 114c78: a1 e4 6e 13 00 mov 0x136ee4,%eax <== NOT EXECUTED 114c7d: a3 d0 6c 13 00 mov %eax,0x136cd0 <== NOT EXECUTED _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 114c82: a1 0c 6e 13 00 mov 0x136e0c,%eax <== NOT EXECUTED 114c87: a3 cc 6c 13 00 mov %eax,0x136ccc <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 114c8c: a1 78 6d 13 00 mov 0x136d78,%eax <== NOT EXECUTED 114c91: 40 inc %eax <== NOT EXECUTED 114c92: a3 78 6d 13 00 mov %eax,0x136d78 <== NOT EXECUTED /* * Insert the timers that were inserted before we got to run. * This should be done with dispatching disabled. */ _Thread_Disable_dispatch(); _Timer_Server_process_insertions(); 114c97: e8 60 ff ff ff call 114bfc <_Timer_Server_process_insertions> <== NOT EXECUTED _Thread_Enable_dispatch(); 114c9c: e8 e3 27 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 114ca1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 114ca4: a1 78 6d 13 00 mov 0x136d78,%eax <== NOT EXECUTED 114ca9: 40 inc %eax <== NOT EXECUTED 114caa: a3 78 6d 13 00 mov %eax,0x136d78 <== NOT EXECUTED /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 114caf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114cb2: 6a 08 push $0x8 <== NOT EXECUTED 114cb4: ff 35 e4 77 13 00 pushl 0x1377e4 <== NOT EXECUTED 114cba: e8 bd 31 00 00 call 117e7c <_Thread_Set_state> <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 114cbf: 8b 15 c0 6c 13 00 mov 0x136cc0,%edx <== NOT EXECUTED _Timer_Server_reset_ticks_timer(); 114cc5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114cc8: 81 fa c4 6c 13 00 cmp $0x136cc4,%edx <== NOT EXECUTED 114cce: 74 1f je 114cef <_Timer_Server_body+0x93> <== NOT EXECUTED 114cd0: a1 e4 77 13 00 mov 0x1377e4,%eax <== NOT EXECUTED Heap_Control *the_heap, 114cd5: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 114cd8: 89 50 54 mov %edx,0x54(%eax) <== NOT EXECUTED void *starting_address, size_t *size 114cdb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114cde: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 114ce1: 50 push %eax <== NOT EXECUTED 114ce2: 68 5c 6e 13 00 push $0x136e5c <== NOT EXECUTED 114ce7: e8 60 3a 00 00 call 11874c <_Watchdog_Insert> <== NOT EXECUTED 114cec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 114cef: a1 d4 6c 13 00 mov 0x136cd4,%eax <== NOT EXECUTED _Timer_Server_reset_seconds_timer(); 114cf4: 3d d8 6c 13 00 cmp $0x136cd8,%eax <== NOT EXECUTED 114cf9: 74 1d je 114d18 <_Timer_Server_body+0xbc> <== NOT EXECUTED * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, 114cfb: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 114cfe: a3 0c 6d 13 00 mov %eax,0x136d0c <== NOT EXECUTED size_t size ); 114d03: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114d06: 68 00 6d 13 00 push $0x136d00 <== NOT EXECUTED 114d0b: 68 50 6e 13 00 push $0x136e50 <== NOT EXECUTED 114d10: e8 37 3a 00 00 call 11874c <_Watchdog_Insert> <== NOT EXECUTED 114d15: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 114d18: e8 67 27 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 114d1d: a1 78 6d 13 00 mov 0x136d78,%eax <== NOT EXECUTED 114d22: 40 inc %eax <== NOT EXECUTED 114d23: a3 78 6d 13 00 mov %eax,0x136d78 <== NOT EXECUTED /* * 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(); 114d28: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114d2b: a1 e4 77 13 00 mov 0x1377e4,%eax <== NOT EXECUTED 114d30: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 114d33: 50 push %eax <== NOT EXECUTED 114d34: e8 43 3b 00 00 call 11887c <_Watchdog_Remove> <== NOT EXECUTED _Timer_Server_stop_seconds_timer(); 114d39: c7 04 24 00 6d 13 00 movl $0x136d00,(%esp) <== NOT EXECUTED 114d40: e8 37 3b 00 00 call 11887c <_Watchdog_Remove> <== NOT EXECUTED ) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 114d45: 8b 15 e4 6e 13 00 mov 0x136ee4,%edx <== NOT EXECUTED if ( snapshot >= _Timer_Server_ticks_last_time ) 114d4b: a1 d0 6c 13 00 mov 0x136cd0,%eax <== NOT EXECUTED 114d50: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114d53: 39 c2 cmp %eax,%edx <== NOT EXECUTED 114d55: 72 7d jb 114dd4 <_Timer_Server_body+0x178> <== NOT EXECUTED ticks = snapshot - _Timer_Server_ticks_last_time; 114d57: 89 d1 mov %edx,%ecx <== NOT EXECUTED 114d59: 29 c1 sub %eax,%ecx <== NOT EXECUTED 114d5b: 89 c8 mov %ecx,%eax <== NOT EXECUTED else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; _Timer_Server_ticks_last_time = snapshot; 114d5d: 89 15 d0 6c 13 00 mov %edx,0x136cd0 <== NOT EXECUTED _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire ); 114d63: 53 push %ebx <== NOT EXECUTED 114d64: 57 push %edi <== NOT EXECUTED 114d65: 50 push %eax <== NOT EXECUTED 114d66: 68 c0 6c 13 00 push $0x136cc0 <== NOT EXECUTED 114d6b: e8 48 39 00 00 call 1186b8 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED /* * Process the seconds chain. Start by checking that the Time * of Day (TOD) has not been set backwards. If it has then * we want to adjust the _Timer_Seconds_chain to indicate this. */ snapshot = _TOD_Seconds_since_epoch; 114d70: 8b 1d 0c 6e 13 00 mov 0x136e0c,%ebx <== NOT EXECUTED if ( snapshot > _Timer_Server_seconds_last_time ) { 114d76: a1 cc 6c 13 00 mov 0x136ccc,%eax <== NOT EXECUTED 114d7b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114d7e: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 114d80: 77 5a ja 114ddc <_Timer_Server_body+0x180> <== NOT EXECUTED * TOD has been set forward. */ ticks = snapshot - _Timer_Server_seconds_last_time; _Watchdog_Adjust_to_chain( &_Timer_Seconds_chain, ticks, to_fire ); } else if ( snapshot < _Timer_Server_seconds_last_time ) { 114d82: 72 70 jb 114df4 <_Timer_Server_body+0x198> <== NOT EXECUTED * TOD has been set backwards. */ ticks = _Timer_Server_seconds_last_time - snapshot; _Watchdog_Adjust( &_Timer_Seconds_chain, WATCHDOG_BACKWARD, ticks ); } _Timer_Server_seconds_last_time = snapshot; 114d84: 89 1d cc 6c 13 00 mov %ebx,0x136ccc <== NOT EXECUTED _Timer_Server_process_seconds_chain( &to_fire ); /* * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); 114d8a: e8 6d fe ff ff call 114bfc <_Timer_Server_process_insertions> <== NOT EXECUTED /* * Enable dispatching to process the set that are ready "to fire." */ _Thread_Enable_dispatch(); 114d8f: e8 f0 26 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED */ while (1) { Watchdog_Control *watch; ISR_Level level; _ISR_Disable( level ); 114d94: 9c pushf <== NOT EXECUTED 114d95: fa cli <== NOT EXECUTED 114d96: 59 pop %ecx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 114d97: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 114d9a: 39 d6 cmp %edx,%esi <== NOT EXECUTED 114d9c: 74 2c je 114dca <_Timer_Server_body+0x16e> <== NOT EXECUTED 114d9e: 66 90 xchg %ax,%ax <== NOT EXECUTED 114da0: 8b 02 mov (%edx),%eax <== NOT EXECUTED 114da2: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 114da5: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED if ( watch == NULL ) { _ISR_Enable( level ); break; } watch->state = WATCHDOG_INACTIVE; 114da8: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) <== NOT EXECUTED _ISR_Enable( level ); 114daf: 51 push %ecx <== NOT EXECUTED 114db0: 9d popf <== NOT EXECUTED (*watch->routine)( watch->id, watch->user_data ); 114db1: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114db4: ff 72 24 pushl 0x24(%edx) <== NOT EXECUTED 114db7: ff 72 20 pushl 0x20(%edx) <== NOT EXECUTED 114dba: ff 52 1c call *0x1c(%edx) <== NOT EXECUTED */ while (1) { Watchdog_Control *watch; ISR_Level level; _ISR_Disable( level ); 114dbd: 9c pushf <== NOT EXECUTED 114dbe: fa cli <== NOT EXECUTED 114dbf: 59 pop %ecx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 114dc0: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 114dc3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114dc6: 39 d6 cmp %edx,%esi <== NOT EXECUTED 114dc8: 75 d6 jne 114da0 <_Timer_Server_body+0x144> <== NOT EXECUTED watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire ); if ( watch == NULL ) { _ISR_Enable( level ); 114dca: 51 push %ecx <== NOT EXECUTED 114dcb: 9d popf <== NOT EXECUTED 114dcc: e9 d3 fe ff ff jmp 114ca4 <_Timer_Server_body+0x48> <== NOT EXECUTED 114dd1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED snapshot = _Watchdog_Ticks_since_boot; if ( snapshot >= _Timer_Server_ticks_last_time ) ticks = snapshot - _Timer_Server_ticks_last_time; else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; 114dd4: f7 d0 not %eax <== NOT EXECUTED 114dd6: 01 d0 add %edx,%eax <== NOT EXECUTED 114dd8: eb 83 jmp 114d5d <_Timer_Server_body+0x101> <== NOT EXECUTED 114dda: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * This path is for normal forward movement and cases where the * TOD has been set forward. */ ticks = snapshot - _Timer_Server_seconds_last_time; _Watchdog_Adjust_to_chain( &_Timer_Seconds_chain, ticks, to_fire ); 114ddc: 51 push %ecx <== NOT EXECUTED 114ddd: 57 push %edi <== NOT EXECUTED 114dde: 89 da mov %ebx,%edx <== NOT EXECUTED 114de0: 29 c2 sub %eax,%edx <== NOT EXECUTED 114de2: 52 push %edx <== NOT EXECUTED 114de3: 68 d4 6c 13 00 push $0x136cd4 <== NOT EXECUTED 114de8: e8 cb 38 00 00 call 1186b8 <_Watchdog_Adjust_to_chain> <== NOT EXECUTED 114ded: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114df0: eb 92 jmp 114d84 <_Timer_Server_body+0x128> <== NOT EXECUTED 114df2: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * The current TOD is before the last TOD which indicates that * TOD has been set backwards. */ ticks = _Timer_Server_seconds_last_time - snapshot; _Watchdog_Adjust( &_Timer_Seconds_chain, WATCHDOG_BACKWARD, ticks ); 114df4: 52 push %edx <== NOT EXECUTED 114df5: 29 d8 sub %ebx,%eax <== NOT EXECUTED 114df7: 50 push %eax <== NOT EXECUTED 114df8: 6a 01 push $0x1 <== NOT EXECUTED 114dfa: 68 d4 6c 13 00 push $0x136cd4 <== NOT EXECUTED 114dff: e8 38 38 00 00 call 11863c <_Watchdog_Adjust> <== NOT EXECUTED 114e04: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114e07: e9 78 ff ff ff jmp 114d84 <_Timer_Server_body+0x128> <== NOT EXECUTED 00114bfc <_Timer_Server_process_insertions>: * onto one of the Timer Server chains. * * @note It is only to be called from the Timer Server task. */ static void _Timer_Server_process_insertions(void) { 114bfc: 55 push %ebp <== NOT EXECUTED 114bfd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114bff: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114c02: eb 0a jmp 114c0e <_Timer_Server_process_insertions+0x12> <== NOT EXECUTED if ( the_timer == NULL ) break; if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { 114c04: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 114c07: 74 37 je 114c40 <_Timer_Server_process_insertions+0x44> <== NOT EXECUTED } /* * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); 114c09: e8 ee ff ff ff call 114bfc <_Timer_Server_process_insertions> <== NOT EXECUTED static void _Timer_Server_process_insertions(void) { Timer_Control *the_timer; while ( 1 ) { the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted ); 114c0e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114c11: 68 e0 6c 13 00 push $0x136ce0 <== NOT EXECUTED 114c16: e8 0d 09 00 00 call 115528 <_Chain_Get> <== NOT EXECUTED if ( the_timer == NULL ) 114c1b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114c1e: 85 c0 test %eax,%eax <== NOT EXECUTED 114c20: 74 36 je 114c58 <_Timer_Server_process_insertions+0x5c> <== NOT EXECUTED break; if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { 114c22: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 114c25: 83 fa 01 cmp $0x1,%edx <== NOT EXECUTED 114c28: 75 da jne 114c04 <_Timer_Server_process_insertions+0x8> <== NOT EXECUTED _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 114c2a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114c2d: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 114c30: 50 push %eax <== NOT EXECUTED 114c31: 68 c0 6c 13 00 push $0x136cc0 <== NOT EXECUTED 114c36: e8 11 3b 00 00 call 11874c <_Watchdog_Insert> <== NOT EXECUTED 114c3b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114c3e: eb c9 jmp 114c09 <_Timer_Server_process_insertions+0xd> <== NOT EXECUTED } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { _Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker ); 114c40: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114c43: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 114c46: 50 push %eax <== NOT EXECUTED 114c47: 68 d4 6c 13 00 push $0x136cd4 <== NOT EXECUTED 114c4c: e8 fb 3a 00 00 call 11874c <_Watchdog_Insert> <== NOT EXECUTED 114c51: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114c54: eb b3 jmp 114c09 <_Timer_Server_process_insertions+0xd> <== NOT EXECUTED 114c56: 66 90 xchg %ax,%ax <== NOT EXECUTED * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); } } 114c58: c9 leave <== NOT EXECUTED 114c59: c3 ret <== NOT EXECUTED 00114bc0 <_Timer_Server_schedule_operation_method>: * the directive invoking this is executed. */ static void _Timer_Server_schedule_operation_method( Timer_Control *the_timer ) { 114bc0: 55 push %ebp <== NOT EXECUTED 114bc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114bc3: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED _Chain_Append( &_Timer_To_be_inserted, &the_timer->Object.Node ); 114bc6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114bc9: 68 e0 6c 13 00 push $0x136ce0 <== NOT EXECUTED 114bce: e8 31 09 00 00 call 115504 <_Chain_Append> <== NOT EXECUTED _Watchdog_Remove( &_Timer_Server->Timer ); 114bd3: a1 e4 77 13 00 mov 0x1377e4,%eax <== NOT EXECUTED 114bd8: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 114bdb: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 114bde: e8 99 3c 00 00 call 11887c <_Watchdog_Remove> <== NOT EXECUTED _Thread_Delay_ended( _Timer_Server->Object.id, NULL ); 114be3: 5a pop %edx <== NOT EXECUTED 114be4: 59 pop %ecx <== NOT EXECUTED 114be5: 6a 00 push $0x0 <== NOT EXECUTED 114be7: a1 e4 77 13 00 mov 0x1377e4,%eax <== NOT EXECUTED 114bec: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 114bef: e8 f8 26 00 00 call 1172ec <_Thread_Delay_ended> <== NOT EXECUTED 114bf4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 114bf7: c9 leave <== NOT EXECUTED 114bf8: c3 ret <== NOT EXECUTED 0010cf7c <_Timespec_Add_to>: uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) { 10cf7c: 55 push %ebp <== NOT EXECUTED 10cf7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cf7f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10cf82: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED uint32_t seconds = add->tv_sec; 10cf85: 8b 08 mov (%eax),%ecx <== NOT EXECUTED /* Add the basics */ time->tv_sec += add->tv_sec; 10cf87: 01 0a add %ecx,(%edx) <== NOT EXECUTED time->tv_nsec += add->tv_nsec; 10cf89: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10cf8c: 03 42 04 add 0x4(%edx),%eax <== NOT EXECUTED 10cf8f: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 10cf92: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 10cf97: 76 15 jbe 10cfae <_Timespec_Add_to+0x32> <== NOT EXECUTED 10cf99: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 10cf9c: 2d 00 ca 9a 3b sub $0x3b9aca00,%eax <== NOT EXECUTED 10cfa1: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED time->tv_sec++; 10cfa4: ff 02 incl (%edx) <== NOT EXECUTED seconds++; 10cfa6: 41 inc %ecx <== NOT EXECUTED /* Add the basics */ time->tv_sec += add->tv_sec; time->tv_nsec += add->tv_nsec; /* Now adjust it so nanoseconds is in range */ while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 10cfa7: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 10cfac: 77 ee ja 10cf9c <_Timespec_Add_to+0x20> <== NOT EXECUTED time->tv_sec++; seconds++; } return seconds; } 10cfae: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10cfb0: c9 leave <== NOT EXECUTED 10cfb1: c3 ret <== NOT EXECUTED 0010e638 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 10e638: 55 push %ebp <== NOT EXECUTED 10e639: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e63b: 57 push %edi <== NOT EXECUTED 10e63c: 56 push %esi <== NOT EXECUTED 10e63d: 53 push %ebx <== NOT EXECUTED 10e63e: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10e641: 8b 45 08 mov 0x8(%ebp),%eax <== 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; 10e644: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10e646: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED left += lhs->tv_nsec; 10e649: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10e64c: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10e64f: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx <== NOT EXECUTED 10e654: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10e657: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10e659: f7 e9 imul %ecx <== NOT EXECUTED 10e65b: 89 c6 mov %eax,%esi <== NOT EXECUTED 10e65d: 89 d7 mov %edx,%edi <== NOT EXECUTED right += rhs->tv_nsec; 10e65f: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10e662: 99 cltd <== NOT EXECUTED 10e663: 01 c6 add %eax,%esi <== NOT EXECUTED 10e665: 11 d7 adc %edx,%edi <== NOT EXECUTED if ( right == 0 ) { 10e667: 89 f8 mov %edi,%eax <== NOT EXECUTED 10e669: 09 f0 or %esi,%eax <== NOT EXECUTED 10e66b: 74 77 je 10e6e4 <_Timespec_Divide+0xac> <== 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; 10e66d: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10e670: f7 e9 imul %ecx <== NOT EXECUTED 10e672: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10e675: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 10e678: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 10e67b: 99 cltd <== NOT EXECUTED 10e67c: 01 45 e0 add %eax,-0x20(%ebp) <== NOT EXECUTED 10e67f: 11 55 e4 adc %edx,-0x1c(%ebp) <== NOT EXECUTED 10e682: 69 5d e4 a0 86 01 00 imul $0x186a0,-0x1c(%ebp),%ebx <== NOT EXECUTED 10e689: b9 a0 86 01 00 mov $0x186a0,%ecx <== NOT EXECUTED 10e68e: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10e691: f7 e1 mul %ecx <== NOT EXECUTED 10e693: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 10e696: 01 da add %ebx,%edx <== NOT EXECUTED 10e698: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED 10e69b: 57 push %edi <== NOT EXECUTED 10e69c: 56 push %esi <== NOT EXECUTED 10e69d: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 10e6a0: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 10e6a3: e8 c0 b2 00 00 call 119968 <__udivdi3> <== NOT EXECUTED 10e6a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e6ab: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10e6ad: 89 d6 mov %edx,%esi <== NOT EXECUTED *ival_percentage = answer / 1000; 10e6af: 6a 00 push $0x0 <== NOT EXECUTED 10e6b1: 68 e8 03 00 00 push $0x3e8 <== NOT EXECUTED 10e6b6: 52 push %edx <== NOT EXECUTED 10e6b7: 50 push %eax <== NOT EXECUTED 10e6b8: e8 ab b2 00 00 call 119968 <__udivdi3> <== NOT EXECUTED 10e6bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e6c0: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10e6c3: 89 01 mov %eax,(%ecx) <== NOT EXECUTED *fval_percentage = answer % 1000; 10e6c5: 6a 00 push $0x0 <== NOT EXECUTED 10e6c7: 68 e8 03 00 00 push $0x3e8 <== NOT EXECUTED 10e6cc: 56 push %esi <== NOT EXECUTED 10e6cd: 53 push %ebx <== NOT EXECUTED 10e6ce: e8 a1 b3 00 00 call 119a74 <__umoddi3> <== NOT EXECUTED 10e6d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e6d6: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 10e6d9: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } 10e6db: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e6de: 5b pop %ebx <== NOT EXECUTED 10e6df: 5e pop %esi <== NOT EXECUTED 10e6e0: 5f pop %edi <== NOT EXECUTED 10e6e1: c9 leave <== NOT EXECUTED 10e6e2: c3 ret <== NOT EXECUTED 10e6e3: 90 nop <== NOT EXECUTED left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec; if ( right == 0 ) { *ival_percentage = 0; 10e6e4: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10e6e7: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED *fval_percentage = 0; 10e6ed: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10e6f0: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED answer = (left * 100000) / right; *ival_percentage = answer / 1000; *fval_percentage = answer % 1000; } 10e6f6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e6f9: 5b pop %ebx <== NOT EXECUTED 10e6fa: 5e pop %esi <== NOT EXECUTED 10e6fb: 5f pop %edi <== NOT EXECUTED 10e6fc: c9 leave <== NOT EXECUTED 10e6fd: c3 ret <== NOT EXECUTED 00127724 <_Timespec_Divide_by_integer>: void _Timespec_Divide_by_integer( const struct timespec *time, uint32_t iterations, struct timespec *result ) { 127724: 55 push %ebp <== NOT EXECUTED 127725: 89 e5 mov %esp,%ebp <== NOT EXECUTED 127727: 57 push %edi <== NOT EXECUTED 127728: 56 push %esi <== NOT EXECUTED 127729: 53 push %ebx <== NOT EXECUTED 12772a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12772d: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 127730: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ t = time->tv_sec; 127733: 8b 06 mov (%esi),%eax <== NOT EXECUTED 127735: 99 cltd <== NOT EXECUTED t *= TOD_NANOSECONDS_PER_SECOND; 127736: 69 da 00 ca 9a 3b imul $0x3b9aca00,%edx,%ebx <== NOT EXECUTED 12773c: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx <== NOT EXECUTED 127741: f7 e1 mul %ecx <== NOT EXECUTED 127743: 8d 14 13 lea (%ebx,%edx,1),%edx <== NOT EXECUTED t += time->tv_nsec; 127746: 8b 4e 04 mov 0x4(%esi),%ecx <== NOT EXECUTED 127749: 89 cb mov %ecx,%ebx <== NOT EXECUTED 12774b: c1 fb 1f sar $0x1f,%ebx <== NOT EXECUTED 12774e: 01 c8 add %ecx,%eax <== NOT EXECUTED 127750: 11 da adc %ebx,%edx <== NOT EXECUTED /* * Divide to get nanoseconds per iteration */ t /= iterations; 127752: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 127755: 31 db xor %ebx,%ebx <== NOT EXECUTED 127757: 53 push %ebx <== NOT EXECUTED 127758: 51 push %ecx <== NOT EXECUTED 127759: 52 push %edx <== NOT EXECUTED 12775a: 50 push %eax <== NOT EXECUTED 12775b: e8 2c 7f 01 00 call 13f68c <__udivdi3> <== NOT EXECUTED 127760: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 127763: 89 c3 mov %eax,%ebx <== NOT EXECUTED 127765: 89 d6 mov %edx,%esi <== NOT EXECUTED /* * Put it back in the timespec result */ result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 127767: 6a 00 push $0x0 <== NOT EXECUTED 127769: 68 00 ca 9a 3b push $0x3b9aca00 <== NOT EXECUTED 12776e: 52 push %edx <== NOT EXECUTED 12776f: 50 push %eax <== NOT EXECUTED 127770: e8 17 7f 01 00 call 13f68c <__udivdi3> <== NOT EXECUTED 127775: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 127778: 89 07 mov %eax,(%edi) <== NOT EXECUTED result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND; 12777a: 6a 00 push $0x0 <== NOT EXECUTED 12777c: 68 00 ca 9a 3b push $0x3b9aca00 <== NOT EXECUTED 127781: 56 push %esi <== NOT EXECUTED 127782: 53 push %ebx <== NOT EXECUTED 127783: e8 10 80 01 00 call 13f798 <__umoddi3> <== NOT EXECUTED 127788: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12778b: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED } 12778e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 127791: 5b pop %ebx <== NOT EXECUTED 127792: 5e pop %esi <== NOT EXECUTED 127793: 5f pop %edi <== NOT EXECUTED 127794: c9 leave <== NOT EXECUTED 127795: c3 ret <== NOT EXECUTED 00116fdc <_Timespec_From_ticks>: void _Timespec_From_ticks( uint32_t ticks, struct timespec *time ) { 116fdc: 55 push %ebp <== NOT EXECUTED 116fdd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116fdf: 53 push %ebx <== NOT EXECUTED 116fe0: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 116fe3: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED uint32_t usecs; usecs = ticks * _TOD_Microseconds_per_tick; 116fe6: 0f af 1d 80 de 12 00 imul 0x12de80,%ebx <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 116fed: ba 83 de 1b 43 mov $0x431bde83,%edx <== NOT EXECUTED 116ff2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 116ff4: f7 e2 mul %edx <== NOT EXECUTED 116ff6: c1 ea 12 shr $0x12,%edx <== NOT EXECUTED 116ff9: 89 11 mov %edx,(%ecx) <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 116ffb: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 116ffe: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 117001: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 117004: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 117007: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 11700a: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 11700d: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 117010: 29 d3 sub %edx,%ebx <== NOT EXECUTED 117012: 8d 04 9b lea (%ebx,%ebx,4),%eax <== NOT EXECUTED 117015: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 117018: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 11701b: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 11701e: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED TOD_NANOSECONDS_PER_MICROSECOND; } 117021: 5b pop %ebx <== NOT EXECUTED 117022: c9 leave <== NOT EXECUTED 117023: c3 ret <== NOT EXECUTED 0010ec40 <_Timespec_Greater_than>: bool _Timespec_Greater_than( const struct timespec *lhs, const struct timespec *rhs ) { 10ec40: 55 push %ebp <== NOT EXECUTED 10ec41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ec43: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10ec46: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED if ( lhs->tv_sec > rhs->tv_sec ) 10ec49: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10ec4b: 39 02 cmp %eax,(%edx) <== NOT EXECUTED 10ec4d: 7f 11 jg 10ec60 <_Timespec_Greater_than+0x20> <== NOT EXECUTED return TRUE; if ( lhs->tv_sec < rhs->tv_sec ) 10ec4f: 7c 0b jl 10ec5c <_Timespec_Greater_than+0x1c> <== NOT EXECUTED return FALSE; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec > rhs->tv_nsec ) 10ec51: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10ec54: 3b 41 04 cmp 0x4(%ecx),%eax <== NOT EXECUTED 10ec57: 0f 9f c0 setg %al <== NOT EXECUTED return TRUE; return FALSE; } 10ec5a: c9 leave <== NOT EXECUTED 10ec5b: c3 ret <== NOT EXECUTED ) { if ( lhs->tv_sec > rhs->tv_sec ) return TRUE; if ( lhs->tv_sec < rhs->tv_sec ) 10ec5c: 31 c0 xor %eax,%eax <== NOT EXECUTED /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec > rhs->tv_nsec ) return TRUE; return FALSE; } 10ec5e: c9 leave <== NOT EXECUTED 10ec5f: c3 ret <== NOT EXECUTED bool _Timespec_Greater_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec > rhs->tv_sec ) 10ec60: b0 01 mov $0x1,%al <== NOT EXECUTED /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec > rhs->tv_nsec ) return TRUE; return FALSE; } 10ec62: c9 leave <== NOT EXECUTED 10ec63: c3 ret <== NOT EXECUTED 00117024 <_Timespec_Is_valid>: #include bool _Timespec_Is_valid( const struct timespec *time ) { 117024: 55 push %ebp <== NOT EXECUTED 117025: 89 e5 mov %esp,%ebp <== NOT EXECUTED 117027: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !time ) 11702a: 85 c0 test %eax,%eax <== NOT EXECUTED 11702c: 74 1a je 117048 <_Timespec_Is_valid+0x24> <== NOT EXECUTED return FALSE; if ( time->tv_sec < 0 ) 11702e: 8b 10 mov (%eax),%edx <== NOT EXECUTED 117030: 85 d2 test %edx,%edx <== NOT EXECUTED 117032: 78 14 js 117048 <_Timespec_Is_valid+0x24> <== NOT EXECUTED return FALSE; if ( time->tv_nsec < 0 ) 117034: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 117037: 85 c0 test %eax,%eax <== NOT EXECUTED 117039: 78 0d js 117048 <_Timespec_Is_valid+0x24> <== NOT EXECUTED 11703b: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 117040: 0f 96 c0 setbe %al <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return FALSE; return TRUE; } 117043: c9 leave <== NOT EXECUTED 117044: c3 ret <== NOT EXECUTED 117045: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return FALSE; if ( time->tv_sec < 0 ) return FALSE; if ( time->tv_nsec < 0 ) 117048: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return FALSE; return TRUE; } 11704a: c9 leave <== NOT EXECUTED 11704b: c3 ret <== NOT EXECUTED 0010ffe4 <_Timespec_Less_than>: bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { 10ffe4: 55 push %ebp <== NOT EXECUTED 10ffe5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ffe7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10ffea: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED if ( lhs->tv_sec < rhs->tv_sec ) 10ffed: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10ffef: 39 02 cmp %eax,(%edx) <== NOT EXECUTED 10fff1: 7c 11 jl 110004 <_Timespec_Less_than+0x20> <== NOT EXECUTED return TRUE; if ( lhs->tv_sec > rhs->tv_sec ) 10fff3: 7f 0b jg 110000 <_Timespec_Less_than+0x1c> <== NOT EXECUTED return FALSE; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) 10fff5: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10fff8: 3b 41 04 cmp 0x4(%ecx),%eax <== NOT EXECUTED 10fffb: 0f 9c c0 setl %al <== NOT EXECUTED return TRUE; return FALSE; } 10fffe: c9 leave <== NOT EXECUTED 10ffff: c3 ret <== NOT EXECUTED ) { if ( lhs->tv_sec < rhs->tv_sec ) return TRUE; if ( lhs->tv_sec > rhs->tv_sec ) 110000: 31 c0 xor %eax,%eax <== NOT EXECUTED /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) return TRUE; return FALSE; } 110002: c9 leave <== NOT EXECUTED 110003: c3 ret <== NOT EXECUTED bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec < rhs->tv_sec ) 110004: b0 01 mov $0x1,%al <== NOT EXECUTED /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) return TRUE; return FALSE; } 110006: c9 leave <== NOT EXECUTED 110007: c3 ret <== NOT EXECUTED 0010cfb4 <_Timespec_Subtract>: void _Timespec_Subtract( const struct timespec *start, const struct timespec *end, struct timespec *result ) { 10cfb4: 55 push %ebp <== NOT EXECUTED 10cfb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cfb7: 53 push %ebx <== NOT EXECUTED 10cfb8: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10cfbb: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10cfbe: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED if (end->tv_nsec < start->tv_nsec) { 10cfc1: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 10cfc4: 3b 51 04 cmp 0x4(%ecx),%edx <== NOT EXECUTED 10cfc7: 7c 0f jl 10cfd8 <_Timespec_Subtract+0x24> <== NOT EXECUTED result->tv_sec = end->tv_sec - start->tv_sec - 1; result->tv_nsec = (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec; } else { result->tv_sec = end->tv_sec - start->tv_sec; 10cfc9: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10cfcb: 2b 01 sub (%ecx),%eax <== NOT EXECUTED 10cfcd: 89 03 mov %eax,(%ebx) <== NOT EXECUTED result->tv_nsec = end->tv_nsec - start->tv_nsec; 10cfcf: 2b 51 04 sub 0x4(%ecx),%edx <== NOT EXECUTED 10cfd2: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED } } 10cfd5: 5b pop %ebx <== NOT EXECUTED 10cfd6: c9 leave <== NOT EXECUTED 10cfd7: c3 ret <== NOT EXECUTED struct timespec *result ) { if (end->tv_nsec < start->tv_nsec) { result->tv_sec = end->tv_sec - start->tv_sec - 1; 10cfd8: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10cfda: 48 dec %eax <== NOT EXECUTED 10cfdb: 2b 01 sub (%ecx),%eax <== NOT EXECUTED 10cfdd: 89 03 mov %eax,(%ebx) <== NOT EXECUTED result->tv_nsec = 10cfdf: 8d 82 00 ca 9a 3b lea 0x3b9aca00(%edx),%eax <== NOT EXECUTED 10cfe5: 2b 41 04 sub 0x4(%ecx),%eax <== NOT EXECUTED 10cfe8: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED (TOD_NANOSECONDS_PER_SECOND - start->tv_nsec) + end->tv_nsec; } else { result->tv_sec = end->tv_sec - start->tv_sec; result->tv_nsec = end->tv_nsec - start->tv_nsec; } } 10cfeb: 5b pop %ebx <== NOT EXECUTED 10cfec: c9 leave <== NOT EXECUTED 10cfed: c3 ret <== NOT EXECUTED 0010ff00 <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 10ff00: 55 push %ebp <== NOT EXECUTED 10ff01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ff03: 57 push %edi <== NOT EXECUTED 10ff04: 56 push %esi <== NOT EXECUTED 10ff05: 53 push %ebx <== NOT EXECUTED 10ff06: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ff09: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 10ff0c: 8b 30 mov (%eax),%esi <== NOT EXECUTED 10ff0e: 85 f6 test %esi,%esi <== NOT EXECUTED 10ff10: 74 3e je 10ff50 <_Timespec_To_ticks+0x50> <== NOT EXECUTED 10ff12: 8b 58 04 mov 0x4(%eax),%ebx <== NOT EXECUTED return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 10ff15: 8b 0d 80 f9 11 00 mov 0x11f980,%ecx <== NOT EXECUTED 10ff1b: bf 40 42 0f 00 mov $0xf4240,%edi <== NOT EXECUTED 10ff20: 89 f8 mov %edi,%eax <== NOT EXECUTED 10ff22: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ff24: f7 f1 div %ecx <== NOT EXECUTED 10ff26: 89 c7 mov %eax,%edi <== NOT EXECUTED 10ff28: 0f af fe imul %esi,%edi <== NOT EXECUTED ticks += (time->tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND) / 10ff2b: be d3 4d 62 10 mov $0x10624dd3,%esi <== NOT EXECUTED 10ff30: 89 f0 mov %esi,%eax <== NOT EXECUTED 10ff32: f7 e3 mul %ebx <== NOT EXECUTED 10ff34: 89 d3 mov %edx,%ebx <== NOT EXECUTED 10ff36: c1 eb 06 shr $0x6,%ebx <== NOT EXECUTED 10ff39: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10ff3b: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ff3d: f7 f1 div %ecx <== NOT EXECUTED _TOD_Microseconds_per_tick; if (ticks) 10ff3f: 01 f8 add %edi,%eax <== NOT EXECUTED 10ff41: 75 05 jne 10ff48 <_Timespec_To_ticks+0x48> <== NOT EXECUTED 10ff43: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED return ticks; return 1; } 10ff48: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10ff4b: 5b pop %ebx <== NOT EXECUTED 10ff4c: 5e pop %esi <== NOT EXECUTED 10ff4d: 5f pop %edi <== NOT EXECUTED 10ff4e: c9 leave <== NOT EXECUTED 10ff4f: c3 ret <== NOT EXECUTED const struct timespec *time ) { uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 10ff50: 8b 58 04 mov 0x4(%eax),%ebx <== NOT EXECUTED 10ff53: 85 db test %ebx,%ebx <== NOT EXECUTED 10ff55: 75 be jne 10ff15 <_Timespec_To_ticks+0x15> <== NOT EXECUTED 10ff57: 31 c0 xor %eax,%eax <== NOT EXECUTED if (ticks) return ticks; return 1; } 10ff59: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10ff5c: 5b pop %ebx <== NOT EXECUTED 10ff5d: 5e pop %esi <== NOT EXECUTED 10ff5e: 5f pop %edi <== NOT EXECUTED 10ff5f: c9 leave <== NOT EXECUTED 10ff60: c3 ret <== NOT EXECUTED 0010ff64 <_User_extensions_Add_API_set>: */ void _User_extensions_Add_API_set ( User_extensions_Control *the_extension ) { 10ff64: 55 push %ebp <== NOT EXECUTED 10ff65: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ff67: 53 push %ebx <== NOT EXECUTED 10ff68: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ff6b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Chain_Append( &_User_extensions_List, &the_extension->Node ); 10ff6e: 53 push %ebx <== NOT EXECUTED 10ff6f: 68 0c fa 11 00 push $0x11fa0c <== NOT EXECUTED 10ff74: e8 63 ae ff ff call 10addc <_Chain_Append> <== NOT EXECUTED /* * If a switch handler is present, append it to the switch chain. */ if ( the_extension->Callouts.thread_switch != NULL ) { 10ff79: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 10ff7c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ff7f: 85 c0 test %eax,%eax <== NOT EXECUTED 10ff81: 74 17 je 10ff9a <_User_extensions_Add_API_set+0x36> <== NOT EXECUTED the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch; 10ff83: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _Chain_Append( 10ff86: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ff89: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10ff8c: 50 push %eax <== NOT EXECUTED 10ff8d: 68 bc f7 11 00 push $0x11f7bc <== NOT EXECUTED 10ff92: e8 45 ae ff ff call 10addc <_Chain_Append> <== NOT EXECUTED 10ff97: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10ff9a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ff9d: c9 leave <== NOT EXECUTED 10ff9e: c3 ret <== NOT EXECUTED 0010ffa0 <_User_extensions_Add_set>: void _User_extensions_Add_set ( User_extensions_Control *the_extension, User_extensions_Table *extension_table ) { 10ffa0: 55 push %ebp <== NOT EXECUTED 10ffa1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ffa3: 57 push %edi <== NOT EXECUTED 10ffa4: 56 push %esi <== NOT EXECUTED 10ffa5: 53 push %ebx <== NOT EXECUTED 10ffa6: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10ffa9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10ffac: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ffaf: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED the_extension->Callouts = *extension_table; 10ffb2: 8d 7b 14 lea 0x14(%ebx),%edi <== NOT EXECUTED 10ffb5: b9 08 00 00 00 mov $0x8,%ecx <== NOT EXECUTED 10ffba: 89 c6 mov %eax,%esi <== NOT EXECUTED 10ffbc: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Chain_Append( &_User_extensions_List, &the_extension->Node ); 10ffbe: 53 push %ebx <== NOT EXECUTED 10ffbf: 68 0c fa 11 00 push $0x11fa0c <== NOT EXECUTED 10ffc4: e8 13 ae ff ff call 10addc <_Chain_Append> <== NOT EXECUTED /* * If a switch handler is present, append it to the switch chain. */ if ( extension_table->thread_switch != NULL ) { 10ffc9: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10ffcc: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10ffcf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ffd2: 85 c0 test %eax,%eax <== NOT EXECUTED 10ffd4: 74 1e je 10fff4 <_User_extensions_Add_set+0x54> <== NOT EXECUTED the_extension->Switch.thread_switch = extension_table->thread_switch; 10ffd6: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _Chain_Append( 10ffd9: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10ffdc: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10ffdf: c7 45 08 bc f7 11 00 movl $0x11f7bc,0x8(%ebp) <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10ffe6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ffe9: 5b pop %ebx <== NOT EXECUTED 10ffea: 5e pop %esi <== NOT EXECUTED 10ffeb: 5f pop %edi <== NOT EXECUTED 10ffec: c9 leave <== NOT EXECUTED * If a switch handler is present, append it to the switch chain. */ if ( extension_table->thread_switch != NULL ) { the_extension->Switch.thread_switch = extension_table->thread_switch; _Chain_Append( 10ffed: e9 ea ad ff ff jmp 10addc <_Chain_Append> <== NOT EXECUTED 10fff2: 66 90 xchg %ax,%ax <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10fff4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fff7: 5b pop %ebx <== NOT EXECUTED 10fff8: 5e pop %esi <== NOT EXECUTED 10fff9: 5f pop %edi <== NOT EXECUTED 10fffa: c9 leave <== NOT EXECUTED 10fffb: c3 ret <== NOT EXECUTED 0010d10c <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10d10c: 55 push %ebp <== NOT EXECUTED 10d10d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d10f: 57 push %edi <== NOT EXECUTED 10d110: 56 push %esi <== NOT EXECUTED 10d111: 53 push %ebx <== NOT EXECUTED 10d112: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d115: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10d118: 8a 45 0c mov 0xc(%ebp),%al <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10d11b: 8b 1d 14 fa 11 00 mov 0x11fa14,%ebx <== NOT EXECUTED !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d121: 81 fb 0c fa 11 00 cmp $0x11fa0c,%ebx <== NOT EXECUTED 10d127: 74 20 je 10d149 <_User_extensions_Fatal+0x3d> <== NOT EXECUTED the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10d129: 0f b6 f0 movzbl %al,%esi <== NOT EXECUTED !_Chain_Is_head( &_User_extensions_List, the_node ) ; the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) 10d12c: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10d12f: 85 c0 test %eax,%eax <== NOT EXECUTED 10d131: 74 0b je 10d13e <_User_extensions_Fatal+0x32> <== NOT EXECUTED (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10d133: 52 push %edx <== NOT EXECUTED 10d134: 57 push %edi <== NOT EXECUTED 10d135: 56 push %esi <== NOT EXECUTED 10d136: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d139: ff d0 call *%eax <== NOT EXECUTED 10d13b: 83 c4 10 add $0x10,%esp <== 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 ) { 10d13e: 8b 5b 04 mov 0x4(%ebx),%ebx <== 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 ) ; 10d141: 81 fb 0c fa 11 00 cmp $0x11fa0c,%ebx <== NOT EXECUTED 10d147: 75 e3 jne 10d12c <_User_extensions_Fatal+0x20> <== NOT EXECUTED the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 10d149: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d14c: 5b pop %ebx <== NOT EXECUTED 10d14d: 5e pop %esi <== NOT EXECUTED 10d14e: 5f pop %edi <== NOT EXECUTED 10d14f: c9 leave <== NOT EXECUTED 10d150: c3 ret <== NOT EXECUTED 0010cff0 <_User_extensions_Handler_initialization>: void _User_extensions_Handler_initialization ( uint32_t number_of_extensions, User_extensions_Table *initial_extensions ) { 10cff0: 55 push %ebp <== NOT EXECUTED 10cff1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cff3: 57 push %edi <== NOT EXECUTED 10cff4: 56 push %esi <== NOT EXECUTED 10cff5: 53 push %ebx <== NOT EXECUTED 10cff6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cff9: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10cffc: c7 05 0c fa 11 00 10 movl $0x11fa10,0x11fa0c <== NOT EXECUTED 10d003: fa 11 00 <== NOT EXECUTED 10d006: c7 05 10 fa 11 00 00 movl $0x0,0x11fa10 <== NOT EXECUTED 10d00d: 00 00 00 <== NOT EXECUTED 10d010: c7 05 14 fa 11 00 0c movl $0x11fa0c,0x11fa14 <== NOT EXECUTED 10d017: fa 11 00 <== NOT EXECUTED 10d01a: c7 05 bc f7 11 00 c0 movl $0x11f7c0,0x11f7bc <== NOT EXECUTED 10d021: f7 11 00 <== NOT EXECUTED 10d024: c7 05 c0 f7 11 00 00 movl $0x0,0x11f7c0 <== NOT EXECUTED 10d02b: 00 00 00 <== NOT EXECUTED 10d02e: c7 05 c4 f7 11 00 bc movl $0x11f7bc,0x11f7c4 <== NOT EXECUTED 10d035: f7 11 00 <== NOT EXECUTED uint32_t i; _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10d038: 85 f6 test %esi,%esi <== NOT EXECUTED 10d03a: 74 50 je 10d08c <_User_extensions_Handler_initialization+0x9c> <== NOT EXECUTED extension = (User_extensions_Control *) 10d03c: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10d03f: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10d042: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 10d045: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 10d04c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d04f: 53 push %ebx <== NOT EXECUTED 10d050: e8 43 04 00 00 call 10d498 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10d055: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10d058: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d05a: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 10d05d: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10d05f: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10d061: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d064: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d067: 85 c0 test %eax,%eax <== NOT EXECUTED 10d069: 74 21 je 10d08c <_User_extensions_Handler_initialization+0x9c> <== NOT EXECUTED 10d06b: 31 db xor %ebx,%ebx <== NOT EXECUTED 10d06d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _User_extensions_Add_set (extension, &initial_extensions[i]); 10d070: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d073: 56 push %esi <== NOT EXECUTED 10d074: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10d077: e8 24 2f 00 00 call 10ffa0 <_User_extensions_Add_set> <== NOT EXECUTED extension++; 10d07c: 83 45 ec 34 addl $0x34,-0x14(%ebp) <== NOT EXECUTED extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10d080: 43 inc %ebx <== NOT EXECUTED 10d081: 83 c6 20 add $0x20,%esi <== NOT EXECUTED 10d084: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d087: 39 5d 08 cmp %ebx,0x8(%ebp) <== NOT EXECUTED 10d08a: 77 e4 ja 10d070 <_User_extensions_Handler_initialization+0x80> <== NOT EXECUTED _User_extensions_Add_set (extension, &initial_extensions[i]); extension++; } } } 10d08c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d08f: 5b pop %ebx <== NOT EXECUTED 10d090: 5e pop %esi <== NOT EXECUTED 10d091: 5f pop %edi <== NOT EXECUTED 10d092: c9 leave <== NOT EXECUTED 10d093: c3 ret <== NOT EXECUTED 00111f28 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 111f28: 55 push %ebp <== NOT EXECUTED 111f29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111f2b: 53 push %ebx <== NOT EXECUTED 111f2c: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 111f2f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Chain_Extract( &the_extension->Node ); 111f32: 53 push %ebx <== NOT EXECUTED 111f33: e8 2c 45 00 00 call 116464 <_Chain_Extract> <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 111f38: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111f3b: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 111f3e: 85 c0 test %eax,%eax <== NOT EXECUTED 111f40: 74 12 je 111f54 <_User_extensions_Remove_set+0x2c> <== NOT EXECUTED _Chain_Extract( &the_extension->Switch.Node ); 111f42: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 111f45: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 111f48: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111f4b: c9 leave <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) _Chain_Extract( &the_extension->Switch.Node ); 111f4c: e9 13 45 00 00 jmp 116464 <_Chain_Extract> <== NOT EXECUTED 111f51: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } 111f54: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111f57: c9 leave <== NOT EXECUTED 111f58: c3 ret <== NOT EXECUTED 0010d094 <_User_extensions_Thread_begin>: */ void _User_extensions_Thread_begin ( Thread_Control *executing ) { 10d094: 55 push %ebp <== NOT EXECUTED 10d095: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d097: 56 push %esi <== NOT EXECUTED 10d098: 53 push %ebx <== NOT EXECUTED 10d099: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; 10d09c: 8b 1d 0c fa 11 00 mov 0x11fa0c,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d0a2: 81 fb 10 fa 11 00 cmp $0x11fa10,%ebx <== NOT EXECUTED 10d0a8: 74 1c je 10d0c6 <_User_extensions_Thread_begin+0x32> <== NOT EXECUTED 10d0aa: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) 10d0ac: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10d0af: 85 c0 test %eax,%eax <== NOT EXECUTED 10d0b1: 74 09 je 10d0bc <_User_extensions_Thread_begin+0x28> <== NOT EXECUTED (*the_extension->Callouts.thread_begin)( executing ); 10d0b3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d0b6: 56 push %esi <== NOT EXECUTED 10d0b7: ff d0 call *%eax <== NOT EXECUTED 10d0b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10d0bc: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d0be: 81 fb 10 fa 11 00 cmp $0x11fa10,%ebx <== NOT EXECUTED 10d0c4: 75 e6 jne 10d0ac <_User_extensions_Thread_begin+0x18> <== NOT EXECUTED the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) (*the_extension->Callouts.thread_begin)( executing ); } } 10d0c6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d0c9: 5b pop %ebx <== NOT EXECUTED 10d0ca: 5e pop %esi <== NOT EXECUTED 10d0cb: c9 leave <== NOT EXECUTED 10d0cc: c3 ret <== NOT EXECUTED 0010d154 <_User_extensions_Thread_create>: */ bool _User_extensions_Thread_create ( Thread_Control *the_thread ) { 10d154: 55 push %ebp <== NOT EXECUTED 10d155: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d157: 56 push %esi <== NOT EXECUTED 10d158: 53 push %ebx <== NOT EXECUTED 10d159: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _User_extensions_List.first ; 10d15c: 8b 1d 0c fa 11 00 mov 0x11fa0c,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d162: 81 fb 10 fa 11 00 cmp $0x11fa10,%ebx <== NOT EXECUTED 10d168: 74 26 je 10d190 <_User_extensions_Thread_create+0x3c> <== NOT EXECUTED 10d16a: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_create != NULL ) { 10d16c: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10d16f: 85 c0 test %eax,%eax <== NOT EXECUTED 10d171: 74 13 je 10d186 <_User_extensions_Thread_create+0x32> <== NOT EXECUTED status = (*the_extension->Callouts.thread_create)( 10d173: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d176: 56 push %esi <== NOT EXECUTED 10d177: ff 35 7c f8 11 00 pushl 0x11f87c <== NOT EXECUTED 10d17d: ff d0 call *%eax <== NOT EXECUTED _Thread_Executing, the_thread ); if ( !status ) 10d17f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d182: 84 c0 test %al,%al <== NOT EXECUTED 10d184: 74 0c je 10d192 <_User_extensions_Thread_create+0x3e> <== NOT EXECUTED User_extensions_Control *the_extension; bool status; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10d186: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d188: 81 fb 10 fa 11 00 cmp $0x11fa10,%ebx <== NOT EXECUTED 10d18e: 75 dc jne 10d16c <_User_extensions_Thread_create+0x18> <== NOT EXECUTED 10d190: b0 01 mov $0x1,%al <== NOT EXECUTED return FALSE; } } return TRUE; } 10d192: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d195: 5b pop %ebx <== NOT EXECUTED 10d196: 5e pop %esi <== NOT EXECUTED 10d197: c9 leave <== NOT EXECUTED 10d198: c3 ret <== NOT EXECUTED 0010d19c <_User_extensions_Thread_delete>: */ void _User_extensions_Thread_delete ( Thread_Control *the_thread ) { 10d19c: 55 push %ebp <== NOT EXECUTED 10d19d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d19f: 56 push %esi <== NOT EXECUTED 10d1a0: 53 push %ebx <== NOT EXECUTED 10d1a1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10d1a4: 8b 1d 14 fa 11 00 mov 0x11fa14,%ebx <== NOT EXECUTED !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d1aa: 81 fb 0c fa 11 00 cmp $0x11fa0c,%ebx <== NOT EXECUTED 10d1b0: 74 23 je 10d1d5 <_User_extensions_Thread_delete+0x39> <== NOT EXECUTED 10d1b2: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_delete != NULL ) 10d1b4: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 10d1b7: 85 c0 test %eax,%eax <== NOT EXECUTED 10d1b9: 74 0f je 10d1ca <_User_extensions_Thread_delete+0x2e> <== NOT EXECUTED (*the_extension->Callouts.thread_delete)( 10d1bb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d1be: 56 push %esi <== NOT EXECUTED 10d1bf: ff 35 7c f8 11 00 pushl 0x11f87c <== NOT EXECUTED 10d1c5: ff d0 call *%eax <== NOT EXECUTED 10d1c7: 83 c4 10 add $0x10,%esp <== 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 ) { 10d1ca: 8b 5b 04 mov 0x4(%ebx),%ebx <== 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 ) ; 10d1cd: 81 fb 0c fa 11 00 cmp $0x11fa0c,%ebx <== NOT EXECUTED 10d1d3: 75 df jne 10d1b4 <_User_extensions_Thread_delete+0x18> <== NOT EXECUTED (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10d1d5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d1d8: 5b pop %ebx <== NOT EXECUTED 10d1d9: 5e pop %esi <== NOT EXECUTED 10d1da: c9 leave <== NOT EXECUTED 10d1db: c3 ret <== NOT EXECUTED 0010d0d0 <_User_extensions_Thread_exitted>: */ void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 10d0d0: 55 push %ebp <== NOT EXECUTED 10d0d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d0d3: 56 push %esi <== NOT EXECUTED 10d0d4: 53 push %ebx <== NOT EXECUTED 10d0d5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10d0d8: 8b 1d 14 fa 11 00 mov 0x11fa14,%ebx <== NOT EXECUTED !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d0de: 81 fb 0c fa 11 00 cmp $0x11fa0c,%ebx <== NOT EXECUTED 10d0e4: 74 1d je 10d103 <_User_extensions_Thread_exitted+0x33> <== NOT EXECUTED 10d0e6: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) 10d0e8: 8b 43 2c mov 0x2c(%ebx),%eax <== NOT EXECUTED 10d0eb: 85 c0 test %eax,%eax <== NOT EXECUTED 10d0ed: 74 09 je 10d0f8 <_User_extensions_Thread_exitted+0x28> <== NOT EXECUTED (*the_extension->Callouts.thread_exitted)( executing ); 10d0ef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d0f2: 56 push %esi <== NOT EXECUTED 10d0f3: ff d0 call *%eax <== NOT EXECUTED 10d0f5: 83 c4 10 add $0x10,%esp <== 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 ) { 10d0f8: 8b 5b 04 mov 0x4(%ebx),%ebx <== 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 ) ; 10d0fb: 81 fb 0c fa 11 00 cmp $0x11fa0c,%ebx <== NOT EXECUTED 10d101: 75 e5 jne 10d0e8 <_User_extensions_Thread_exitted+0x18> <== NOT EXECUTED the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) (*the_extension->Callouts.thread_exitted)( executing ); } } 10d103: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d106: 5b pop %ebx <== NOT EXECUTED 10d107: 5e pop %esi <== NOT EXECUTED 10d108: c9 leave <== NOT EXECUTED 10d109: c3 ret <== NOT EXECUTED 0010dc98 <_User_extensions_Thread_restart>: */ void _User_extensions_Thread_restart ( Thread_Control *the_thread ) { 10dc98: 55 push %ebp <== NOT EXECUTED 10dc99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc9b: 56 push %esi <== NOT EXECUTED 10dc9c: 53 push %ebx <== NOT EXECUTED 10dc9d: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; 10dca0: 8b 1d ec 2f 12 00 mov 0x122fec,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10dca6: 81 fb f0 2f 12 00 cmp $0x122ff0,%ebx <== NOT EXECUTED 10dcac: 74 22 je 10dcd0 <_User_extensions_Thread_restart+0x38> <== NOT EXECUTED 10dcae: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_restart != NULL ) 10dcb0: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10dcb3: 85 c0 test %eax,%eax <== NOT EXECUTED 10dcb5: 74 0f je 10dcc6 <_User_extensions_Thread_restart+0x2e> <== NOT EXECUTED (*the_extension->Callouts.thread_restart)( 10dcb7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dcba: 56 push %esi <== NOT EXECUTED 10dcbb: ff 35 5c 2e 12 00 pushl 0x122e5c <== NOT EXECUTED 10dcc1: ff d0 call *%eax <== NOT EXECUTED 10dcc3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10dcc6: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10dcc8: 81 fb f0 2f 12 00 cmp $0x122ff0,%ebx <== NOT EXECUTED 10dcce: 75 e0 jne 10dcb0 <_User_extensions_Thread_restart+0x18> <== NOT EXECUTED (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10dcd0: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10dcd3: 5b pop %ebx <== NOT EXECUTED 10dcd4: 5e pop %esi <== NOT EXECUTED 10dcd5: c9 leave <== NOT EXECUTED 10dcd6: c3 ret <== NOT EXECUTED 0010d1dc <_User_extensions_Thread_start>: */ void _User_extensions_Thread_start ( Thread_Control *the_thread ) { 10d1dc: 55 push %ebp <== NOT EXECUTED 10d1dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d1df: 56 push %esi <== NOT EXECUTED 10d1e0: 53 push %ebx <== NOT EXECUTED 10d1e1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; 10d1e4: 8b 1d 0c fa 11 00 mov 0x11fa0c,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d1ea: 81 fb 10 fa 11 00 cmp $0x11fa10,%ebx <== NOT EXECUTED 10d1f0: 74 22 je 10d214 <_User_extensions_Thread_start+0x38> <== NOT EXECUTED 10d1f2: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_start != NULL ) 10d1f4: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10d1f7: 85 c0 test %eax,%eax <== NOT EXECUTED 10d1f9: 74 0f je 10d20a <_User_extensions_Thread_start+0x2e> <== NOT EXECUTED (*the_extension->Callouts.thread_start)( 10d1fb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d1fe: 56 push %esi <== NOT EXECUTED 10d1ff: ff 35 7c f8 11 00 pushl 0x11f87c <== NOT EXECUTED 10d205: ff d0 call *%eax <== NOT EXECUTED 10d207: 83 c4 10 add $0x10,%esp <== NOT EXECUTED Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; the_node = the_node->next ) { 10d20a: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d20c: 81 fb 10 fa 11 00 cmp $0x11fa10,%ebx <== NOT EXECUTED 10d212: 75 e0 jne 10d1f4 <_User_extensions_Thread_start+0x18> <== NOT EXECUTED (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10d214: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d217: 5b pop %ebx <== NOT EXECUTED 10d218: 5e pop %esi <== NOT EXECUTED 10d219: c9 leave <== NOT EXECUTED 10d21a: c3 ret <== NOT EXECUTED 0010d21c <_User_extensions_Thread_switch>: */ void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) { 10d21c: 55 push %ebp <== NOT EXECUTED 10d21d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d21f: 57 push %edi <== NOT EXECUTED 10d220: 56 push %esi <== NOT EXECUTED 10d221: 53 push %ebx <== NOT EXECUTED 10d222: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d225: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10d228: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _User_extensions_Switches_list.first ; 10d22b: 8b 1d bc f7 11 00 mov 0x11f7bc,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; 10d231: 81 fb c0 f7 11 00 cmp $0x11f7c0,%ebx <== NOT EXECUTED 10d237: 74 18 je 10d251 <_User_extensions_Thread_switch+0x35> <== NOT EXECUTED 10d239: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_node = the_node->next ) { the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); 10d23c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d23f: 56 push %esi <== NOT EXECUTED 10d240: 57 push %edi <== NOT EXECUTED 10d241: ff 53 08 call *0x8(%ebx) <== NOT EXECUTED Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _User_extensions_Switches_list.first ; !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; the_node = the_node->next ) { 10d244: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED { Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _User_extensions_Switches_list.first ; !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; 10d246: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d249: 81 fb c0 f7 11 00 cmp $0x11f7c0,%ebx <== NOT EXECUTED 10d24f: 75 eb jne 10d23c <_User_extensions_Thread_switch+0x20> <== NOT EXECUTED the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10d251: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d254: 5b pop %ebx <== NOT EXECUTED 10d255: 5e pop %esi <== NOT EXECUTED 10d256: 5f pop %edi <== NOT EXECUTED 10d257: c9 leave <== NOT EXECUTED 10d258: c3 ret <== NOT EXECUTED 0010ea04 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10ea04: 55 push %ebp <== NOT EXECUTED 10ea05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ea07: 57 push %edi <== NOT EXECUTED 10ea08: 56 push %esi <== NOT EXECUTED 10ea09: 53 push %ebx <== NOT EXECUTED 10ea0a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ea0d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10ea10: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10ea13: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10ea16: 9c pushf <== NOT EXECUTED 10ea17: fa cli <== NOT EXECUTED 10ea18: 5a pop %edx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10ea19: 8b 07 mov (%edi),%eax <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10ea1b: 8d 5f 04 lea 0x4(%edi),%ebx <== NOT EXECUTED 10ea1e: 89 5d f0 mov %ebx,-0x10(%ebp) <== NOT EXECUTED * hence the compiler must not assume *header to remain * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { 10ea21: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10ea23: 74 3f je 10ea64 <_Watchdog_Adjust+0x60> <== NOT EXECUTED switch ( direction ) { 10ea25: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ea27: 75 47 jne 10ea70 <_Watchdog_Adjust+0x6c> <== NOT EXECUTED case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10ea29: 85 f6 test %esi,%esi <== NOT EXECUTED 10ea2b: 74 37 je 10ea64 <_Watchdog_Adjust+0x60> <== NOT EXECUTED if ( units < _Watchdog_First( header )->delta_interval ) { 10ea2d: 8b 58 10 mov 0x10(%eax),%ebx <== NOT EXECUTED 10ea30: 39 de cmp %ebx,%esi <== NOT EXECUTED 10ea32: 73 0f jae 10ea43 <_Watchdog_Adjust+0x3f> <== NOT EXECUTED 10ea34: eb 42 jmp 10ea78 <_Watchdog_Adjust+0x74> <== NOT EXECUTED 10ea36: 66 90 xchg %ax,%ax <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10ea38: 29 de sub %ebx,%esi <== NOT EXECUTED 10ea3a: 74 28 je 10ea64 <_Watchdog_Adjust+0x60> <== NOT EXECUTED if ( units < _Watchdog_First( header )->delta_interval ) { 10ea3c: 8b 58 10 mov 0x10(%eax),%ebx <== NOT EXECUTED 10ea3f: 39 f3 cmp %esi,%ebx <== NOT EXECUTED 10ea41: 77 35 ja 10ea78 <_Watchdog_Adjust+0x74> <== NOT EXECUTED _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 10ea43: c7 40 10 01 00 00 00 movl $0x1,0x10(%eax) <== NOT EXECUTED _ISR_Enable( level ); 10ea4a: 52 push %edx <== NOT EXECUTED 10ea4b: 9d popf <== NOT EXECUTED _Watchdog_Tickle( header ); 10ea4c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ea4f: 57 push %edi <== NOT EXECUTED 10ea50: e8 c7 01 00 00 call 10ec1c <_Watchdog_Tickle> <== NOT EXECUTED _ISR_Disable( level ); 10ea55: 9c pushf <== NOT EXECUTED 10ea56: fa cli <== NOT EXECUTED 10ea57: 5a pop %edx <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10ea58: 8b 07 mov (%edi),%eax <== NOT EXECUTED if ( _Chain_Is_empty( header ) ) 10ea5a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ea5d: 39 45 f0 cmp %eax,-0x10(%ebp) <== NOT EXECUTED 10ea60: 75 d6 jne 10ea38 <_Watchdog_Adjust+0x34> <== NOT EXECUTED 10ea62: 66 90 xchg %ax,%ax <== NOT EXECUTED } break; } } _ISR_Enable( level ); 10ea64: 52 push %edx <== NOT EXECUTED 10ea65: 9d popf <== NOT EXECUTED } 10ea66: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ea69: 5b pop %ebx <== NOT EXECUTED 10ea6a: 5e pop %esi <== NOT EXECUTED 10ea6b: 5f pop %edi <== NOT EXECUTED 10ea6c: c9 leave <== NOT EXECUTED 10ea6d: c3 ret <== NOT EXECUTED 10ea6e: 66 90 xchg %ax,%ax <== NOT EXECUTED * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { switch ( direction ) { 10ea70: 49 dec %ecx <== NOT EXECUTED 10ea71: 75 f1 jne 10ea64 <_Watchdog_Adjust+0x60> <== NOT EXECUTED case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10ea73: 01 70 10 add %esi,0x10(%eax) <== NOT EXECUTED 10ea76: eb ec jmp 10ea64 <_Watchdog_Adjust+0x60> <== NOT EXECUTED break; case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; 10ea78: 29 f3 sub %esi,%ebx <== NOT EXECUTED 10ea7a: 89 58 10 mov %ebx,0x10(%eax) <== NOT EXECUTED 10ea7d: eb e5 jmp 10ea64 <_Watchdog_Adjust+0x60> <== NOT EXECUTED 001186b8 <_Watchdog_Adjust_to_chain>: Chain_Control *header, Watchdog_Interval units_arg, Chain_Control *to_fire ) { 1186b8: 55 push %ebp <== NOT EXECUTED 1186b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1186bb: 57 push %edi <== NOT EXECUTED 1186bc: 56 push %esi <== NOT EXECUTED 1186bd: 53 push %ebx <== NOT EXECUTED 1186be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1186c1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1186c4: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED Watchdog_Interval units = units_arg; ISR_Level level; Chain_Node *node; if ( !units ) { 1186c7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1186ca: 85 c0 test %eax,%eax <== NOT EXECUTED 1186cc: 74 6a je 118738 <_Watchdog_Adjust_to_chain+0x80> <== NOT EXECUTED return; } _ISR_Disable( level ); 1186ce: 9c pushf <== NOT EXECUTED 1186cf: fa cli <== NOT EXECUTED 1186d0: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED 1186d3: 8b 13 mov (%ebx),%edx <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 1186d5: 8d 4b 04 lea 0x4(%ebx),%ecx <== NOT EXECUTED if ( !_Chain_Is_empty( header ) ) { 1186d8: 39 ca cmp %ecx,%edx <== NOT EXECUTED 1186da: 74 58 je 118734 <_Watchdog_Adjust_to_chain+0x7c> <== NOT EXECUTED 1186dc: 8b 72 10 mov 0x10(%edx),%esi <== NOT EXECUTED 1186df: 8d 47 04 lea 0x4(%edi),%eax <== NOT EXECUTED 1186e2: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 1186e5: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1186e8: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 1186eb: 90 nop <== NOT EXECUTED while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 1186ec: 3b 75 e8 cmp -0x18(%ebp),%esi <== NOT EXECUTED 1186ef: 77 3c ja 11872d <_Watchdog_Adjust_to_chain+0x75> <== NOT EXECUTED _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 0; 1186f1: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED 1186f8: eb 2b jmp 118725 <_Watchdog_Adjust_to_chain+0x6d> <== NOT EXECUTED 1186fa: 66 90 xchg %ax,%ax <== NOT EXECUTED 1186fc: 8b 02 mov (%edx),%eax <== NOT EXECUTED 1186fe: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 118700: 89 58 04 mov %ebx,0x4(%eax) <== NOT EXECUTED 118703: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 118706: 89 02 mov %eax,(%edx) <== NOT EXECUTED 118708: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED 11870b: 89 57 08 mov %edx,0x8(%edi) <== NOT EXECUTED 11870e: 89 10 mov %edx,(%eax) <== NOT EXECUTED 118710: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED do { node = _Chain_Get_unprotected( header ); _Chain_Append_unprotected( to_fire, node ); _ISR_Flash( level ); 118713: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 118716: 9d popf <== NOT EXECUTED 118717: fa cli <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 118718: 8b 13 mov (%ebx),%edx <== NOT EXECUTED } while ( !_Chain_Is_empty( header ) && _Watchdog_First( header )->delta_interval == 0 ); 11871a: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 11871c: 74 16 je 118734 <_Watchdog_Adjust_to_chain+0x7c> <== NOT EXECUTED 11871e: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 118721: 85 c0 test %eax,%eax <== NOT EXECUTED 118723: 75 1b jne 118740 <_Watchdog_Adjust_to_chain+0x88> <== NOT EXECUTED 118725: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 118727: 75 d3 jne 1186fc <_Watchdog_Adjust_to_chain+0x44> <== NOT EXECUTED 118729: 31 d2 xor %edx,%edx <== NOT EXECUTED 11872b: eb d6 jmp 118703 <_Watchdog_Adjust_to_chain+0x4b> <== NOT EXECUTED _ISR_Disable( level ); if ( !_Chain_Is_empty( header ) ) { while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; 11872d: 2b 75 e8 sub -0x18(%ebp),%esi <== NOT EXECUTED 118730: 89 72 10 mov %esi,0x10(%edx) <== NOT EXECUTED 118733: 90 nop <== NOT EXECUTED break; } } } _ISR_Enable( level ); 118734: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 118737: 9d popf <== NOT EXECUTED } 118738: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 11873b: 5b pop %ebx <== NOT EXECUTED 11873c: 5e pop %esi <== NOT EXECUTED 11873d: 5f pop %edi <== NOT EXECUTED 11873e: c9 leave <== NOT EXECUTED 11873f: c3 ret <== NOT EXECUTED return; } _ISR_Disable( level ); if ( !_Chain_Is_empty( header ) ) { while ( units ) { 118740: 29 75 e8 sub %esi,-0x18(%ebp) <== NOT EXECUTED 118743: 74 ef je 118734 <_Watchdog_Adjust_to_chain+0x7c> <== NOT EXECUTED 118745: 89 c6 mov %eax,%esi <== NOT EXECUTED 118747: eb a3 jmp 1186ec <_Watchdog_Adjust_to_chain+0x34> <== NOT EXECUTED 0010d32c <_Watchdog_Handler_initialization>: * * Output parameters: NONE */ void _Watchdog_Handler_initialization( void ) { 10d32c: 55 push %ebp <== NOT EXECUTED 10d32d: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Watchdog_Sync_count = 0; 10d32f: c7 05 20 f9 11 00 00 movl $0x0,0x11f920 <== NOT EXECUTED 10d336: 00 00 00 <== NOT EXECUTED _Watchdog_Sync_level = 0; 10d339: c7 05 78 f8 11 00 00 movl $0x0,0x11f878 <== NOT EXECUTED 10d340: 00 00 00 <== NOT EXECUTED _Watchdog_Ticks_since_boot = 0; 10d343: c7 05 24 f9 11 00 00 movl $0x0,0x11f924 <== NOT EXECUTED 10d34a: 00 00 00 <== NOT EXECUTED 10d34d: c7 05 9c f8 11 00 a0 movl $0x11f8a0,0x11f89c <== NOT EXECUTED 10d354: f8 11 00 <== NOT EXECUTED 10d357: c7 05 a0 f8 11 00 00 movl $0x0,0x11f8a0 <== NOT EXECUTED 10d35e: 00 00 00 <== NOT EXECUTED 10d361: c7 05 a4 f8 11 00 9c movl $0x11f89c,0x11f8a4 <== NOT EXECUTED 10d368: f8 11 00 <== NOT EXECUTED 10d36b: c7 05 90 f8 11 00 94 movl $0x11f894,0x11f890 <== NOT EXECUTED 10d372: f8 11 00 <== NOT EXECUTED 10d375: c7 05 94 f8 11 00 00 movl $0x0,0x11f894 <== NOT EXECUTED 10d37c: 00 00 00 <== NOT EXECUTED 10d37f: c7 05 98 f8 11 00 90 movl $0x11f890,0x11f898 <== NOT EXECUTED 10d386: f8 11 00 <== NOT EXECUTED _Chain_Initialize_empty( &_Watchdog_Ticks_chain ); _Chain_Initialize_empty( &_Watchdog_Seconds_chain ); } 10d389: c9 leave <== NOT EXECUTED 10d38a: c3 ret <== NOT EXECUTED 0010d25c <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 10d25c: 55 push %ebp <== NOT EXECUTED 10d25d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d25f: 57 push %edi <== NOT EXECUTED 10d260: 56 push %esi <== NOT EXECUTED 10d261: 53 push %ebx <== NOT EXECUTED 10d262: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d265: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 10d268: 8b 3d 58 f8 11 00 mov 0x11f858,%edi <== NOT EXECUTED _ISR_Disable( level ); 10d26e: 9c pushf <== NOT EXECUTED 10d26f: fa cli <== NOT EXECUTED 10d270: 8f 45 f0 popl -0x10(%ebp) <== NOT EXECUTED /* * 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 ) { 10d273: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10d276: 85 c0 test %eax,%eax <== NOT EXECUTED 10d278: 75 72 jne 10d2ec <_Watchdog_Insert+0x90> <== NOT EXECUTED _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 10d27a: c7 46 08 01 00 00 00 movl $0x1,0x8(%esi) <== NOT EXECUTED _Watchdog_Sync_count++; 10d281: a1 20 f9 11 00 mov 0x11f920,%eax <== NOT EXECUTED 10d286: 40 inc %eax <== NOT EXECUTED 10d287: a3 20 f9 11 00 mov %eax,0x11f920 <== NOT EXECUTED restart: delta_interval = the_watchdog->initial; 10d28c: 8b 5e 0c mov 0xc(%esi),%ebx <== NOT EXECUTED * cache *header!! * * Till Straumann, 7/2003 (gcc-3.2.2 -O4 on powerpc) * */ for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ; 10d28f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d292: 8b 08 mov (%eax),%ecx <== NOT EXECUTED ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10d294: 85 db test %ebx,%ebx <== NOT EXECUTED 10d296: 74 65 je 10d2fd <_Watchdog_Insert+0xa1> <== NOT EXECUTED 10d298: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10d29a: 85 c0 test %eax,%eax <== NOT EXECUTED 10d29c: 74 5f je 10d2fd <_Watchdog_Insert+0xa1> <== NOT EXECUTED break; if ( delta_interval < after->delta_interval ) { 10d29e: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED 10d2a1: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 10d2a3: 73 21 jae 10d2c6 <_Watchdog_Insert+0x6a> <== NOT EXECUTED 10d2a5: eb 51 jmp 10d2f8 <_Watchdog_Insert+0x9c> <== NOT EXECUTED 10d2a7: 90 nop <== NOT EXECUTED if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 10d2a8: a1 78 f8 11 00 mov 0x11f878,%eax <== NOT EXECUTED 10d2ad: 39 c7 cmp %eax,%edi <== NOT EXECUTED 10d2af: 72 6f jb 10d320 <_Watchdog_Insert+0xc4> <== NOT EXECUTED if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; break; } delta_interval -= after->delta_interval; 10d2b1: 29 d3 sub %edx,%ebx <== NOT EXECUTED ); #ifdef __cplusplus } #endif 10d2b3: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED */ for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ; ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10d2b5: 85 db test %ebx,%ebx <== NOT EXECUTED 10d2b7: 74 44 je 10d2fd <_Watchdog_Insert+0xa1> <== NOT EXECUTED 10d2b9: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10d2bb: 85 d2 test %edx,%edx <== NOT EXECUTED 10d2bd: 74 3e je 10d2fd <_Watchdog_Insert+0xa1> <== NOT EXECUTED break; if ( delta_interval < after->delta_interval ) { 10d2bf: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED 10d2c2: 39 da cmp %ebx,%edx <== NOT EXECUTED 10d2c4: 77 32 ja 10d2f8 <_Watchdog_Insert+0x9c> <== NOT EXECUTED * 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 ); 10d2c6: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10d2c9: 9d popf <== NOT EXECUTED 10d2ca: fa cli <== NOT EXECUTED if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 10d2cb: 83 7e 08 01 cmpl $0x1,0x8(%esi) <== NOT EXECUTED 10d2cf: 74 d7 je 10d2a8 <_Watchdog_Insert+0x4c> <== NOT EXECUTED _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; 10d2d1: 89 3d 78 f8 11 00 mov %edi,0x11f878 <== NOT EXECUTED _Watchdog_Sync_count--; 10d2d7: a1 20 f9 11 00 mov 0x11f920,%eax <== NOT EXECUTED 10d2dc: 48 dec %eax <== NOT EXECUTED 10d2dd: a3 20 f9 11 00 mov %eax,0x11f920 <== NOT EXECUTED _ISR_Enable( level ); 10d2e2: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10d2e5: 9d popf <== NOT EXECUTED } 10d2e6: 58 pop %eax <== NOT EXECUTED 10d2e7: 5b pop %ebx <== NOT EXECUTED 10d2e8: 5e pop %esi <== NOT EXECUTED 10d2e9: 5f pop %edi <== NOT EXECUTED 10d2ea: c9 leave <== NOT EXECUTED 10d2eb: c3 ret <== NOT EXECUTED * 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 ); 10d2ec: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10d2ef: 9d popf <== NOT EXECUTED exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; _Watchdog_Sync_count--; _ISR_Enable( level ); } 10d2f0: 58 pop %eax <== NOT EXECUTED 10d2f1: 5b pop %ebx <== NOT EXECUTED 10d2f2: 5e pop %esi <== NOT EXECUTED 10d2f3: 5f pop %edi <== NOT EXECUTED 10d2f4: c9 leave <== NOT EXECUTED 10d2f5: c3 ret <== NOT EXECUTED 10d2f6: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( delta_interval == 0 || !_Watchdog_Next( after ) ) break; if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; 10d2f8: 29 da sub %ebx,%edx <== NOT EXECUTED 10d2fa: 89 51 10 mov %edx,0x10(%ecx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( 10d2fd: c7 46 08 02 00 00 00 movl $0x2,0x8(%esi) <== NOT EXECUTED } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 10d304: 89 5e 10 mov %ebx,0x10(%esi) <== NOT EXECUTED _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 10d307: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d30a: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10d30d: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10d30f: 89 30 mov %esi,(%eax) <== NOT EXECUTED 10d311: 89 16 mov %edx,(%esi) <== NOT EXECUTED 10d313: 89 72 04 mov %esi,0x4(%edx) <== NOT EXECUTED the_watchdog->start_time = _Watchdog_Ticks_since_boot; 10d316: a1 24 f9 11 00 mov 0x11f924,%eax <== NOT EXECUTED 10d31b: 89 46 14 mov %eax,0x14(%esi) <== NOT EXECUTED 10d31e: eb b1 jmp 10d2d1 <_Watchdog_Insert+0x75> <== 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; 10d320: 89 3d 78 f8 11 00 mov %edi,0x11f878 <== NOT EXECUTED 10d326: e9 61 ff ff ff jmp 10d28c <_Watchdog_Insert+0x30> <== NOT EXECUTED 0010d38c <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10d38c: 55 push %ebp <== NOT EXECUTED 10d38d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d38f: 56 push %esi <== NOT EXECUTED 10d390: 53 push %ebx <== NOT EXECUTED 10d391: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10d394: 9c pushf <== NOT EXECUTED 10d395: fa cli <== NOT EXECUTED 10d396: 5e pop %esi <== NOT EXECUTED previous_state = the_watchdog->state; 10d397: 8b 59 08 mov 0x8(%ecx),%ebx <== NOT EXECUTED switch ( previous_state ) { 10d39a: 83 fb 01 cmp $0x1,%ebx <== NOT EXECUTED 10d39d: 74 4d je 10d3ec <_Watchdog_Remove+0x60> <== NOT EXECUTED 10d39f: 73 13 jae 10d3b4 <_Watchdog_Remove+0x28> <== NOT EXECUTED _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10d3a1: a1 24 f9 11 00 mov 0x11f924,%eax <== NOT EXECUTED 10d3a6: 89 41 18 mov %eax,0x18(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10d3a9: 56 push %esi <== NOT EXECUTED 10d3aa: 9d popf <== NOT EXECUTED return( previous_state ); } 10d3ab: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d3ad: 5b pop %ebx <== NOT EXECUTED 10d3ae: 5e pop %esi <== NOT EXECUTED 10d3af: c9 leave <== NOT EXECUTED 10d3b0: c3 ret <== NOT EXECUTED 10d3b1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); previous_state = the_watchdog->state; switch ( previous_state ) { 10d3b4: 83 fb 03 cmp $0x3,%ebx <== NOT EXECUTED 10d3b7: 77 e8 ja 10d3a1 <_Watchdog_Remove+0x15> <== NOT EXECUTED break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10d3b9: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED ); #ifdef __cplusplus } #endif 10d3c0: 8b 11 mov (%ecx),%edx <== NOT EXECUTED next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 10d3c2: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10d3c4: 85 c0 test %eax,%eax <== NOT EXECUTED 10d3c6: 74 06 je 10d3ce <_Watchdog_Remove+0x42> <== NOT EXECUTED next_watchdog->delta_interval += the_watchdog->delta_interval; 10d3c8: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED 10d3cb: 01 42 10 add %eax,0x10(%edx) <== NOT EXECUTED if ( _Watchdog_Sync_count ) 10d3ce: a1 20 f9 11 00 mov 0x11f920,%eax <== NOT EXECUTED 10d3d3: 85 c0 test %eax,%eax <== NOT EXECUTED 10d3d5: 74 0a je 10d3e1 <_Watchdog_Remove+0x55> <== NOT EXECUTED _Watchdog_Sync_level = _ISR_Nest_level; 10d3d7: a1 58 f8 11 00 mov 0x11f858,%eax <== NOT EXECUTED 10d3dc: a3 78 f8 11 00 mov %eax,0x11f878 <== NOT EXECUTED 10d3e1: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d3e4: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10d3e7: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10d3e9: eb b6 jmp 10d3a1 <_Watchdog_Remove+0x15> <== NOT EXECUTED 10d3eb: 90 nop <== 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; 10d3ec: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED 10d3f3: eb ac jmp 10d3a1 <_Watchdog_Remove+0x15> <== NOT EXECUTED 0010d3f8 <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10d3f8: 55 push %ebp <== NOT EXECUTED 10d3f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d3fb: 57 push %edi <== NOT EXECUTED 10d3fc: 56 push %esi <== NOT EXECUTED 10d3fd: 53 push %ebx <== NOT EXECUTED 10d3fe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d401: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED * See the comment in watchdoginsert.c and watchdogadjust.c * about why it's safe not to declare header a pointer to * volatile data - till, 2003/7 */ _ISR_Disable( level ); 10d404: 9c pushf <== NOT EXECUTED 10d405: fa cli <== NOT EXECUTED 10d406: 5e pop %esi <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 10d407: 8b 17 mov (%edi),%edx <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10d409: 8d 47 04 lea 0x4(%edi),%eax <== NOT EXECUTED 10d40c: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED if ( _Chain_Is_empty( header ) ) 10d40f: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10d411: 74 11 je 10d424 <_Watchdog_Tickle+0x2c> <== NOT EXECUTED 10d413: 89 d3 mov %edx,%ebx <== NOT EXECUTED * to be inserted has already had its delta_interval adjusted to 0, and * so is added to the head of the chain with a delta_interval of 0. * * Steven Johnson - 12/2005 (gcc-3.2.3 -O3 on powerpc) */ if (the_watchdog->delta_interval != 0) { 10d415: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10d418: 85 c0 test %eax,%eax <== NOT EXECUTED 10d41a: 74 34 je 10d450 <_Watchdog_Tickle+0x58> <== NOT EXECUTED the_watchdog->delta_interval--; 10d41c: 48 dec %eax <== NOT EXECUTED 10d41d: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED if ( the_watchdog->delta_interval != 0 ) 10d420: 85 c0 test %eax,%eax <== NOT EXECUTED 10d422: 74 2c je 10d450 <_Watchdog_Tickle+0x58> <== NOT EXECUTED the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); 10d424: 56 push %esi <== NOT EXECUTED 10d425: 9d popf <== NOT EXECUTED } 10d426: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d429: 5b pop %ebx <== NOT EXECUTED 10d42a: 5e pop %esi <== NOT EXECUTED 10d42b: 5f pop %edi <== NOT EXECUTED 10d42c: c9 leave <== NOT EXECUTED 10d42d: c3 ret <== NOT EXECUTED _ISR_Enable( level ); switch( watchdog_state ) { case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10d42e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d431: ff 73 24 pushl 0x24(%ebx) <== NOT EXECUTED 10d434: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10d437: ff 53 1c call *0x1c(%ebx) <== NOT EXECUTED 10d43a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10d43d: 9c pushf <== NOT EXECUTED 10d43e: fa cli <== NOT EXECUTED 10d43f: 5e pop %esi <== NOT EXECUTED 10d440: 8b 07 mov (%edi),%eax <== NOT EXECUTED the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10d442: 39 45 f0 cmp %eax,-0x10(%ebp) <== NOT EXECUTED 10d445: 74 dd je 10d424 <_Watchdog_Tickle+0x2c> <== NOT EXECUTED 10d447: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10d449: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 10d44c: 85 c0 test %eax,%eax <== NOT EXECUTED 10d44e: 75 d4 jne 10d424 <_Watchdog_Tickle+0x2c> <== NOT EXECUTED if ( the_watchdog->delta_interval != 0 ) goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10d450: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d453: 53 push %ebx <== NOT EXECUTED 10d454: e8 33 ff ff ff call 10d38c <_Watchdog_Remove> <== NOT EXECUTED _ISR_Enable( level ); 10d459: 56 push %esi <== NOT EXECUTED 10d45a: 9d popf <== NOT EXECUTED switch( watchdog_state ) { 10d45b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d45e: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10d461: 75 da jne 10d43d <_Watchdog_Tickle+0x45> <== NOT EXECUTED 10d463: eb c9 jmp 10d42e <_Watchdog_Tickle+0x36> <== NOT EXECUTED 0010d480 <_Workspace_Allocate>: * _Workspace_Allocate */ void *_Workspace_Allocate( size_t size ) { 10d480: 55 push %ebp <== NOT EXECUTED 10d481: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d483: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Heap_Allocate( &_Workspace_Area, size ); 10d486: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d489: 68 e0 f7 11 00 push $0x11f7e0 <== NOT EXECUTED 10d48e: e8 a9 24 00 00 call 10f93c <_Heap_Allocate> <== NOT EXECUTED } 10d493: c9 leave <== NOT EXECUTED 10d494: c3 ret <== NOT EXECUTED 0010d498 <_Workspace_Allocate_or_fatal_error>: * _Workspace_Allocate_or_fatal_error */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 10d498: 55 push %ebp <== NOT EXECUTED 10d499: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d49b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED */ void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 10d49e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d4a1: 68 e0 f7 11 00 push $0x11f7e0 <== NOT EXECUTED 10d4a6: e8 91 24 00 00 call 10f93c <_Heap_Allocate> <== NOT EXECUTED { void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) 10d4ab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d4ae: 85 c0 test %eax,%eax <== NOT EXECUTED 10d4b0: 74 02 je 10d4b4 <_Workspace_Allocate_or_fatal_error+0x1c> <== NOT EXECUTED TRUE, INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 10d4b2: c9 leave <== NOT EXECUTED 10d4b3: c3 ret <== NOT EXECUTED void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) _Internal_error_Occurred( 10d4b4: 50 push %eax <== NOT EXECUTED 10d4b5: 6a 04 push $0x4 <== NOT EXECUTED 10d4b7: 6a 01 push $0x1 <== NOT EXECUTED 10d4b9: 6a 00 push $0x0 <== NOT EXECUTED 10d4bb: e8 c0 e0 ff ff call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 0010d468 <_Workspace_Free>: * _Workspace_Free */ bool _Workspace_Free( void *block ) { 10d468: 55 push %ebp <== NOT EXECUTED 10d469: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d46b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Heap_Free( &_Workspace_Area, block ); 10d46e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d471: 68 e0 f7 11 00 push $0x11f7e0 <== NOT EXECUTED 10d476: e8 55 25 00 00 call 10f9d0 <_Heap_Free> <== NOT EXECUTED } 10d47b: c9 leave <== NOT EXECUTED 10d47c: c3 ret <== NOT EXECUTED 0010d4c0 <_Workspace_Handler_initialization>: */ void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 10d4c0: 55 push %ebp <== NOT EXECUTED 10d4c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d4c3: 57 push %edi <== NOT EXECUTED 10d4c4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d4c7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) 10d4ca: 85 d2 test %edx,%edx <== NOT EXECUTED 10d4cc: 74 2e je 10d4fc <_Workspace_Handler_initialization+0x3c> <== NOT EXECUTED 10d4ce: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10d4d1: 75 29 jne 10d4fc <_Workspace_Handler_initialization+0x3c> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _Configuration_Table->do_zero_of_workspace ) 10d4d3: a1 54 f8 11 00 mov 0x11f854,%eax <== NOT EXECUTED 10d4d8: 80 78 28 00 cmpb $0x0,0x28(%eax) <== NOT EXECUTED 10d4dc: 75 2a jne 10d508 <_Workspace_Handler_initialization+0x48> <== NOT EXECUTED memset( starting_address, 0, size ); memory_available = _Heap_Initialize( 10d4de: 6a 04 push $0x4 <== NOT EXECUTED 10d4e0: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d4e3: 52 push %edx <== NOT EXECUTED 10d4e4: 68 e0 f7 11 00 push $0x11f7e0 <== NOT EXECUTED 10d4e9: e8 aa de ff ff call 10b398 <_Heap_Initialize> <== NOT EXECUTED starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 10d4ee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d4f1: 85 c0 test %eax,%eax <== NOT EXECUTED 10d4f3: 74 1e je 10d513 <_Workspace_Handler_initialization+0x53> <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } 10d4f5: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 10d4f8: c9 leave <== NOT EXECUTED 10d4f9: c3 ret <== NOT EXECUTED 10d4fa: 66 90 xchg %ax,%ax <== NOT EXECUTED ) { uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) _Internal_error_Occurred( 10d4fc: 51 push %ecx <== NOT EXECUTED 10d4fd: 6a 02 push $0x2 <== NOT EXECUTED 10d4ff: 6a 01 push $0x1 <== NOT EXECUTED 10d501: 6a 00 push $0x0 <== NOT EXECUTED 10d503: e8 78 e0 ff ff call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _Configuration_Table->do_zero_of_workspace ) memset( starting_address, 0, size ); 10d508: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d50a: 89 d7 mov %edx,%edi <== NOT EXECUTED 10d50c: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10d50f: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 10d511: eb cb jmp 10d4de <_Workspace_Handler_initialization+0x1e> <== NOT EXECUTED size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) _Internal_error_Occurred( 10d513: 52 push %edx <== NOT EXECUTED 10d514: 6a 03 push $0x3 <== NOT EXECUTED 10d516: 6a 01 push $0x1 <== NOT EXECUTED 10d518: 6a 00 push $0x0 <== NOT EXECUTED 10d51a: e8 61 e0 ff ff call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 00106ea8 <__assert>: void __assert( const char *file, int line, const char *failedexpr ) { 106ea8: 55 push %ebp <== NOT EXECUTED 106ea9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106eab: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED __assert_func (file, line, NULL, failedexpr); 106eae: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 106eb1: 6a 00 push $0x0 <== NOT EXECUTED 106eb3: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 106eb6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106eb9: e8 aa ff ff ff call 106e68 <__assert_func> <== NOT EXECUTED 106ebe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 106ec1: c9 leave <== NOT EXECUTED 106ec2: c3 ret <== NOT EXECUTED 00106e68 <__assert_func>: const char *file, int line, const char *func, const char *failedexpr ) { 106e68: 55 push %ebp <== NOT EXECUTED 106e69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106e6b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 106e6e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n", 106e71: 85 c0 test %eax,%eax <== NOT EXECUTED 106e73: 74 27 je 106e9c <__assert_func+0x34> <== NOT EXECUTED 106e75: ba 77 8e 11 00 mov $0x118e77,%edx <== NOT EXECUTED 106e7a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 106e7d: 50 push %eax <== NOT EXECUTED 106e7e: 52 push %edx <== NOT EXECUTED 106e7f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 106e82: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106e85: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 106e88: 68 84 8e 11 00 push $0x118e84 <== NOT EXECUTED 106e8d: e8 62 0f 00 00 call 107df4 <== NOT EXECUTED file, line, (func) ? ", function: " : "", (func) ? func : "" ); rtems_fatal_error_occurred(0); 106e92: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 106e95: 6a 00 push $0x0 <== NOT EXECUTED 106e97: e8 ac 3b 00 00 call 10aa48 <== NOT EXECUTED int line, const char *func, const char *failedexpr ) { printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n", 106e9c: ba e6 8f 11 00 mov $0x118fe6,%edx <== NOT EXECUTED 106ea1: 89 d0 mov %edx,%eax <== NOT EXECUTED 106ea3: eb d5 jmp 106e7a <__assert_func+0x12> <== NOT EXECUTED 00120688 <__env_lock>: 120688: 55 push %ebp <== NOT EXECUTED 120689: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12068b: c9 leave <== NOT EXECUTED 12068c: c3 ret <== NOT EXECUTED 00120690 <__env_unlock>: 120690: 55 push %ebp <== NOT EXECUTED 120691: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120693: c9 leave <== NOT EXECUTED 120694: c3 ret <== NOT EXECUTED 00116f70 <_calloc_r>: void *_calloc_r( struct _reent *ignored, size_t elements, size_t size ) { 116f70: 55 push %ebp <== NOT EXECUTED 116f71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116f73: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return calloc( elements, size ); 116f76: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 116f79: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 116f7c: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 116f7f: c9 leave <== NOT EXECUTED struct _reent *ignored, size_t elements, size_t size ) { return calloc( elements, size ); 116f80: e9 6f 75 ff ff jmp 10e4f4 <== NOT EXECUTED 0010e5b8 <_close_r>: int _close_r( struct _reent *ptr, int fd ) { 10e5b8: 55 push %ebp <== NOT EXECUTED 10e5b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED return close( fd ); 10e5bb: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e5be: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10e5c1: c9 leave <== NOT EXECUTED int _close_r( struct _reent *ptr, int fd ) { return close( fd ); 10e5c2: e9 69 ff ff ff jmp 10e530 <== NOT EXECUTED 001171d4 <_exit>: /* * If the toolset uses init/fini sections, then we need to * run the global destructors now. */ #if defined(__USE_INIT_FINI__) _fini(); 1171d4: 55 push %ebp <== NOT EXECUTED 1171d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1171d7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1171da: e8 5e 07 00 00 call 11793d <_fini> <== NOT EXECUTED * 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(); 1171df: e8 84 ff ff ff call 117168 <== NOT EXECUTED rtems_shutdown_executive(status); 1171e4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1171e7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1171ea: e8 f9 00 00 00 call 1172e8 <== NOT EXECUTED 1171ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1171f2: eb fe jmp 1171f2 <_exit+0x1e> <== NOT EXECUTED 0012fb24 <_fcntl_r>: struct _reent *ptr, int fd, int cmd, int arg ) { 12fb24: 55 push %ebp <== NOT EXECUTED 12fb25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12fb27: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 12fb2a: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return fcntl( fd, cmd, arg ); 12fb2d: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 12fb30: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 12fb33: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 12fb36: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 12fb39: c9 leave <== NOT EXECUTED int fd, int cmd, int arg ) { return fcntl( fd, cmd, arg ); 12fb3a: e9 11 fe ff ff jmp 12f950 <== NOT EXECUTED 00116f88 <_free_r>: void _free_r( struct _reent *ignored, void *ptr ) { 116f88: 55 push %ebp <== NOT EXECUTED 116f89: 89 e5 mov %esp,%ebp <== NOT EXECUTED free( ptr ); 116f8b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 116f8e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 116f91: c9 leave <== NOT EXECUTED void _free_r( struct _reent *ignored, void *ptr ) { free( ptr ); 116f92: e9 09 01 ff ff jmp 1070a0 <== NOT EXECUTED 00117034 <_fstat_r>: int _fstat_r( struct _reent *ptr, int fd, struct stat *buf ) { 117034: 55 push %ebp <== NOT EXECUTED 117035: 89 e5 mov %esp,%ebp <== NOT EXECUTED 117037: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return fstat( fd, buf ); 11703a: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11703d: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 117040: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 117043: c9 leave <== NOT EXECUTED struct _reent *ptr, int fd, struct stat *buf ) { return fstat( fd, buf ); 117044: e9 4f ff ff ff jmp 116f98 <== NOT EXECUTED 0012188c <_getpid_r>: #include pid_t _getpid_r( struct _reent *ptr ) { 12188c: 55 push %ebp <== NOT EXECUTED 12188d: 89 e5 mov %esp,%ebp <== NOT EXECUTED return getpid(); } 12188f: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 121894: c9 leave <== NOT EXECUTED 121895: c3 ret <== NOT EXECUTED 0010e700 <_gettimeofday>: int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { 10e700: 55 push %ebp <== NOT EXECUTED 10e701: 89 e5 mov %esp,%ebp <== NOT EXECUTED return gettimeofday( tp, tzp ); } 10e703: c9 leave <== NOT EXECUTED int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp ); 10e704: e9 a3 ff ff ff jmp 10e6ac <== NOT EXECUTED 0010e70c <_gettimeofday_r>: int _gettimeofday_r( struct _reent *ignored_reentrancy_stuff, struct timeval *tp, struct timezone *tzp ) { 10e70c: 55 push %ebp <== NOT EXECUTED 10e70d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e70f: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return gettimeofday( tp, tzp ); 10e712: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10e715: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10e718: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10e71b: c9 leave <== NOT EXECUTED struct _reent *ignored_reentrancy_stuff, struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp ); 10e71c: e9 8b ff ff ff jmp 10e6ac <== NOT EXECUTED 00121aa8 <_kill_r>: int _kill_r( struct _reent *ptr, pid_t pid, int sig ) { 121aa8: 55 push %ebp <== NOT EXECUTED 121aa9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121aab: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 121aae: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED return killinfo( pid, sig, NULL ); 121ab1: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) <== NOT EXECUTED 121ab8: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 121abb: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 121abe: c9 leave <== NOT EXECUTED struct _reent *ptr, pid_t pid, int sig ) { return killinfo( pid, sig, NULL ); 121abf: e9 a4 00 00 00 jmp 121b68 <== NOT EXECUTED 00124acc <_link_r>: int _link_r( struct _reent *ptr, const char *existing, const char *new ) { 124acc: 55 push %ebp <== NOT EXECUTED 124acd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124acf: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return link( existing, new ); 124ad2: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 124ad5: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 124ad8: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 124adb: c9 leave <== NOT EXECUTED struct _reent *ptr, const char *existing, const char *new ) { return link( existing, new ); 124adc: e9 03 fe ff ff jmp 1248e4 <== NOT EXECUTED 0011713c <_lseek_r>: struct _reent *ptr, int fd, off_t offset, int whence ) { 11713c: 55 push %ebp <== NOT EXECUTED 11713d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11713f: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 117142: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return lseek( fd, offset, whence ); 117145: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 117148: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 11714b: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 11714e: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 117151: c9 leave <== NOT EXECUTED int fd, off_t offset, int whence ) { return lseek( fd, offset, whence ); 117152: e9 29 ff ff ff jmp 117080 <== NOT EXECUTED 00124c78 <_lstat_r>: int _STAT_R_NAME( struct _reent *ptr, const char *path, struct stat *buf ) { 124c78: 55 push %ebp <== NOT EXECUTED 124c79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124c7b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return _STAT_NAME( path, buf ); 124c7e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 124c81: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 124c84: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 124c87: c9 leave <== NOT EXECUTED struct _reent *ptr, const char *path, struct stat *buf ) { return _STAT_NAME( path, buf ); 124c88: e9 2f ff ff ff jmp 124bbc <== NOT EXECUTED 00117158 <_malloc_r>: void *_malloc_r( struct _reent *ignored, size_t size ) { 117158: 55 push %ebp <== NOT EXECUTED 117159: 89 e5 mov %esp,%ebp <== NOT EXECUTED return malloc( size ); 11715b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11715e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 117161: c9 leave <== NOT EXECUTED void *_malloc_r( struct _reent *ignored, size_t size ) { return malloc( size ); 117162: e9 51 01 ff ff jmp 1072b8 <== NOT EXECUTED 00107ac0 <_open_r>: struct _reent *ptr, const char *buf, int flags, int mode ) { 107ac0: 55 push %ebp <== NOT EXECUTED 107ac1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107ac3: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 107ac6: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return open( buf, flags, mode ); 107ac9: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 107acc: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 107acf: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 107ad2: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 107ad5: c9 leave <== NOT EXECUTED const char *buf, int flags, int mode ) { return open( buf, flags, mode ); 107ad6: e9 61 fd ff ff jmp 10783c <== NOT EXECUTED 00117298 <_read_r>: struct _reent *ptr, int fd, void *buf, size_t nbytes ) { 117298: 55 push %ebp <== NOT EXECUTED 117299: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11729b: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 11729e: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return read( fd, buf, nbytes ); 1172a1: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1172a4: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 1172a7: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 1172aa: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 1172ad: c9 leave <== NOT EXECUTED int fd, void *buf, size_t nbytes ) { return read( fd, buf, nbytes ); 1172ae: e9 41 ff ff ff jmp 1171f4 <== NOT EXECUTED 001172b4 <_realloc_r>: void *_realloc_r( struct _reent *ignored, void *ptr, size_t size ) { 1172b4: 55 push %ebp <== NOT EXECUTED 1172b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1172b7: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return realloc( ptr, size ); 1172ba: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1172bd: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1172c0: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 1172c3: c9 leave <== NOT EXECUTED struct _reent *ignored, void *ptr, size_t size ) { return realloc( ptr, size ); 1172c4: e9 4f 00 00 00 jmp 117318 <== NOT EXECUTED 0013f91c <_rename_r>: int _rename_r( struct _reent *ptr, const char *old, const char *new ) { 13f91c: 55 push %ebp <== NOT EXECUTED 13f91d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 13f91f: 53 push %ebx <== NOT EXECUTED 13f920: 83 ec 5c sub $0x5c,%esp <== NOT EXECUTED 13f923: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED struct stat sb; int s; s = stat( old, &sb); 13f926: 8d 45 b0 lea -0x50(%ebp),%eax <== NOT EXECUTED 13f929: 50 push %eax <== NOT EXECUTED 13f92a: 53 push %ebx <== NOT EXECUTED 13f92b: e8 20 d0 fc ff call 10c950 <== NOT EXECUTED if ( s < 0 ) 13f930: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 13f933: 85 c0 test %eax,%eax <== NOT EXECUTED 13f935: 78 2e js 13f965 <_rename_r+0x49> <== NOT EXECUTED return s; s = link( old, new ); 13f937: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 13f93a: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 13f93d: 53 push %ebx <== NOT EXECUTED 13f93e: e8 a1 4f fe ff call 1248e4 <== NOT EXECUTED if ( s < 0 ) 13f943: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 13f946: 85 c0 test %eax,%eax <== NOT EXECUTED 13f948: 78 1b js 13f965 <_rename_r+0x49> <== NOT EXECUTED return s; return S_ISDIR(sb.st_mode) ? rmdir( old ) : unlink( old ); 13f94a: 8b 45 bc mov -0x44(%ebp),%eax <== NOT EXECUTED 13f94d: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 13f952: 3d 00 40 00 00 cmp $0x4000,%eax <== NOT EXECUTED 13f957: 74 13 je 13f96c <_rename_r+0x50> <== NOT EXECUTED 13f959: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 13f95c: 53 push %ebx <== NOT EXECUTED 13f95d: e8 82 ed fc ff call 10e6e4 <== NOT EXECUTED 13f962: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 13f965: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 13f968: c9 leave <== NOT EXECUTED 13f969: c3 ret <== NOT EXECUTED 13f96a: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( s < 0 ) return s; s = link( old, new ); if ( s < 0 ) return s; return S_ISDIR(sb.st_mode) ? rmdir( old ) : unlink( old ); 13f96c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 13f96f: 53 push %ebx <== NOT EXECUTED 13f970: e8 df 58 fe ff call 125254 <== NOT EXECUTED 13f975: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 13f978: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 13f97b: c9 leave <== NOT EXECUTED 13f97c: c3 ret <== NOT EXECUTED 0010ca0c <_stat_r>: int _STAT_R_NAME( struct _reent *ptr, const char *path, struct stat *buf ) { 10ca0c: 55 push %ebp <== NOT EXECUTED 10ca0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca0f: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return _STAT_NAME( path, buf ); 10ca12: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10ca15: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10ca18: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10ca1b: c9 leave <== NOT EXECUTED struct _reent *ptr, const char *path, struct stat *buf ) { return _STAT_NAME( path, buf ); 10ca1c: e9 2f ff ff ff jmp 10c950 <== NOT EXECUTED 0010e808 <_unlink_r>: int _unlink_r( struct _reent *ptr, const char *path ) { 10e808: 55 push %ebp <== NOT EXECUTED 10e809: 89 e5 mov %esp,%ebp <== NOT EXECUTED return unlink( path ); 10e80b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e80e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10e811: c9 leave <== NOT EXECUTED int _unlink_r( struct _reent *ptr, const char *path ) { return unlink( path ); 10e812: e9 cd fe ff ff jmp 10e6e4 <== NOT EXECUTED 001172cc <_write_r>: struct _reent *ptr, int fd, const void *buf, size_t nbytes ) { 1172cc: 55 push %ebp <== NOT EXECUTED 1172cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1172cf: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1172d2: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return write( fd, buf, nbytes ); 1172d5: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1172d8: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 1172db: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 1172de: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 1172e1: c9 leave <== NOT EXECUTED int fd, const void *buf, size_t nbytes ) { return write( fd, buf, nbytes ); 1172e2: e9 1d 01 00 00 jmp 117404 <== NOT EXECUTED 001231d8 : int access( const char *path, int amode ) { 1231d8: 55 push %ebp <== NOT EXECUTED 1231d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1231db: 83 ec 60 sub $0x60,%esp <== NOT EXECUTED struct stat statbuf; if ( stat(path, &statbuf) ) 1231de: 8d 45 b4 lea -0x4c(%ebp),%eax <== NOT EXECUTED 1231e1: 50 push %eax <== NOT EXECUTED 1231e2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1231e5: e8 66 97 fe ff call 10c950 <== NOT EXECUTED 1231ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1231ed: 85 c0 test %eax,%eax <== NOT EXECUTED 1231ef: 75 1f jne 123210 <== NOT EXECUTED return -1; if ( amode & R_OK ) { 1231f1: f6 45 0c 04 testb $0x4,0xc(%ebp) <== NOT EXECUTED 1231f5: 75 11 jne 123208 <== NOT EXECUTED if (!( statbuf.st_mode & S_IREAD )) return -1; } if ( amode & W_OK ) { 1231f7: f6 45 0c 02 testb $0x2,0xc(%ebp) <== NOT EXECUTED 1231fb: 75 27 jne 123224 <== NOT EXECUTED if ( !( statbuf.st_mode & S_IWRITE ) ) return -1; } if ( amode & X_OK ) { 1231fd: f6 45 0c 01 testb $0x1,0xc(%ebp) <== NOT EXECUTED 123201: 75 15 jne 123218 <== NOT EXECUTED if ( !( statbuf.st_mode & S_IEXEC ) ) 123203: 31 c0 xor %eax,%eax <== NOT EXECUTED return -1; } return 0; } 123205: c9 leave <== NOT EXECUTED 123206: c3 ret <== NOT EXECUTED 123207: 90 nop <== NOT EXECUTED if ( stat(path, &statbuf) ) return -1; if ( amode & R_OK ) { if (!( statbuf.st_mode & S_IREAD )) 123208: f6 45 c1 01 testb $0x1,-0x3f(%ebp) <== NOT EXECUTED 12320c: 75 e9 jne 1231f7 <== NOT EXECUTED 12320e: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !( statbuf.st_mode & S_IWRITE ) ) return -1; } if ( amode & X_OK ) { if ( !( statbuf.st_mode & S_IEXEC ) ) 123210: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED return -1; } return 0; } 123215: c9 leave <== NOT EXECUTED 123216: c3 ret <== NOT EXECUTED 123217: 90 nop <== NOT EXECUTED if ( !( statbuf.st_mode & S_IWRITE ) ) return -1; } if ( amode & X_OK ) { if ( !( statbuf.st_mode & S_IEXEC ) ) 123218: f6 45 c0 40 testb $0x40,-0x40(%ebp) <== NOT EXECUTED 12321c: 74 f2 je 123210 <== NOT EXECUTED 12321e: 31 c0 xor %eax,%eax <== NOT EXECUTED 123220: eb e3 jmp 123205 <== NOT EXECUTED 123222: 66 90 xchg %ax,%ax <== NOT EXECUTED if (!( statbuf.st_mode & S_IREAD )) return -1; } if ( amode & W_OK ) { if ( !( statbuf.st_mode & S_IWRITE ) ) 123224: 80 7d c0 00 cmpb $0x0,-0x40(%ebp) <== NOT EXECUTED 123228: 78 d3 js 1231fd <== NOT EXECUTED 12322a: eb e4 jmp 123210 <== NOT EXECUTED 00109fa4 : int adjtime( struct timeval *delta, struct timeval *olddelta ) { 109fa4: 55 push %ebp <== NOT EXECUTED 109fa5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109fa7: 57 push %edi <== NOT EXECUTED 109fa8: 56 push %esi <== NOT EXECUTED 109fa9: 53 push %ebx <== NOT EXECUTED 109faa: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 109fad: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 109fb0: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED long adjustment; /* * Simple validations */ if ( !delta ) 109fb3: 85 f6 test %esi,%esi <== NOT EXECUTED 109fb5: 0f 84 22 01 00 00 je 10a0dd <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND ) 109fbb: 8b 56 04 mov 0x4(%esi),%edx <== NOT EXECUTED 109fbe: 81 fa 3f 42 0f 00 cmp $0xf423f,%edx <== NOT EXECUTED 109fc4: 0f 87 13 01 00 00 ja 10a0dd <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( olddelta ) { 109fca: 85 ff test %edi,%edi <== NOT EXECUTED 109fcc: 74 10 je 109fde <== NOT EXECUTED olddelta->tv_sec = 0; 109fce: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED olddelta->tv_usec = 0; 109fd4: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) <== NOT EXECUTED 109fdb: 8b 56 04 mov 0x4(%esi),%edx <== NOT EXECUTED } /* convert delta to microseconds */ adjustment = (delta->tv_sec * TOD_MICROSECONDS_PER_SECOND); 109fde: 8b 06 mov (%esi),%eax <== NOT EXECUTED 109fe0: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 109fe3: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 109fe6: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 109fe9: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 109fec: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 109fef: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 109ff2: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED adjustment += delta->tv_usec; /* too small to account for */ if ( adjustment < _TOD_Microseconds_per_tick ) 109ff5: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED 109ff8: 3b 05 a0 09 12 00 cmp 0x1209a0,%eax <== NOT EXECUTED 109ffe: 73 0c jae 10a00c <== NOT EXECUTED _Thread_Enable_dispatch(); /* set the user's output */ if ( olddelta ) *olddelta = *delta; 10a000: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10a002: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a005: 5b pop %ebx <== NOT EXECUTED 10a006: 5e pop %esi <== NOT EXECUTED 10a007: 5f pop %edi <== NOT EXECUTED 10a008: c9 leave <== NOT EXECUTED 10a009: c3 ret <== NOT EXECUTED 10a00a: 66 90 xchg %ax,%ax <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a00c: a1 d8 07 12 00 mov 0x1207d8,%eax <== NOT EXECUTED 10a011: 40 inc %eax <== NOT EXECUTED 10a012: a3 d8 07 12 00 mov %eax,0x1207d8 <== NOT EXECUTED * This prevents context switches while we are adjusting the TOD */ _Thread_Disable_dispatch(); _TOD_Get( &ts ); 10a017: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a01a: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10a01d: 50 push %eax <== NOT EXECUTED 10a01e: e8 dd 19 00 00 call 10ba00 <_TOD_Get> <== NOT EXECUTED ts.tv_sec += delta->tv_sec; 10a023: 8b 1e mov (%esi),%ebx <== NOT EXECUTED 10a025: 03 5d ec add -0x14(%ebp),%ebx <== NOT EXECUTED 10a028: 89 5d ec mov %ebx,-0x14(%ebp) <== NOT EXECUTED ts.tv_nsec += delta->tv_usec * TOD_NANOSECONDS_PER_MICROSECOND; 10a02b: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10a02e: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10a031: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10a034: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10a037: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 10a03a: 03 45 f0 add -0x10(%ebp),%eax <== NOT EXECUTED 10a03d: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED /* if adjustment is too much positive */ while ( ts.tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) { 10a040: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a043: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 10a048: 76 3f jbe 10a089 <== NOT EXECUTED ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 10a04a: 8d 88 00 36 65 c4 lea -0x3b9aca00(%eax),%ecx <== NOT EXECUTED int adjtime( struct timeval *delta, struct timeval *olddelta ) { 10a050: 89 ca mov %ecx,%edx <== NOT EXECUTED 10a052: c1 ea 09 shr $0x9,%edx <== NOT EXECUTED 10a055: b8 83 4b 04 00 mov $0x44b83,%eax <== NOT EXECUTED 10a05a: f7 e2 mul %edx <== NOT EXECUTED 10a05c: c1 ea 07 shr $0x7,%edx <== NOT EXECUTED 10a05f: 8d 44 1a 01 lea 0x1(%edx,%ebx,1),%eax <== NOT EXECUTED 10a063: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 10a066: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a069: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a06c: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a06f: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a072: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a075: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a078: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a07b: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a07e: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10a081: c1 e2 09 shl $0x9,%edx <== NOT EXECUTED 10a084: 29 d1 sub %edx,%ecx <== NOT EXECUTED 10a086: 89 4d f0 mov %ecx,-0x10(%ebp) <== NOT EXECUTED ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; ts.tv_sec++; } /* if adjustment is too much negative */ while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) { 10a089: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10a08c: 81 fa 00 36 65 c4 cmp $0xc4653600,%edx <== NOT EXECUTED 10a092: 77 19 ja 10a0ad <== NOT EXECUTED 10a094: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10a097: 90 nop <== NOT EXECUTED ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND; 10a098: 81 c2 00 ca 9a 3b add $0x3b9aca00,%edx <== NOT EXECUTED int adjtime( struct timeval *delta, struct timeval *olddelta ) { 10a09e: 48 dec %eax <== NOT EXECUTED ts.tv_nsec -= TOD_NANOSECONDS_PER_SECOND; ts.tv_sec++; } /* if adjustment is too much negative */ while ( ts.tv_nsec <= (-1 * TOD_NANOSECONDS_PER_SECOND) ) { 10a09f: 81 fa 00 36 65 c4 cmp $0xc4653600,%edx <== NOT EXECUTED 10a0a5: 76 f1 jbe 10a098 <== NOT EXECUTED 10a0a7: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 10a0aa: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED ts.tv_nsec += TOD_NANOSECONDS_PER_SECOND; ts.tv_sec--; } _TOD_Set( &ts ); 10a0ad: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a0b0: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10a0b3: 50 push %eax <== NOT EXECUTED 10a0b4: e8 d7 19 00 00 call 10ba90 <_TOD_Set> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a0b9: e8 5e 2a 00 00 call 10cb1c <_Thread_Enable_dispatch> <== NOT EXECUTED /* set the user's output */ if ( olddelta ) 10a0be: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0c1: 85 ff test %edi,%edi <== NOT EXECUTED 10a0c3: 0f 84 37 ff ff ff je 10a000 <== NOT EXECUTED *olddelta = *delta; 10a0c9: 8b 16 mov (%esi),%edx <== NOT EXECUTED 10a0cb: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10a0ce: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED 10a0d1: 89 17 mov %edx,(%edi) <== NOT EXECUTED 10a0d3: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10a0d5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a0d8: 5b pop %ebx <== NOT EXECUTED 10a0d9: 5e pop %esi <== NOT EXECUTED 10a0da: 5f pop %edi <== NOT EXECUTED 10a0db: c9 leave <== NOT EXECUTED 10a0dc: c3 ret <== NOT EXECUTED */ if ( !delta ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( delta->tv_usec >= TOD_MICROSECONDS_PER_SECOND ) rtems_set_errno_and_return_minus_one( EINVAL ); 10a0dd: e8 fa 73 00 00 call 1114dc <__errno> <== NOT EXECUTED 10a0e2: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10a0e8: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a0ed: e9 10 ff ff ff jmp 10a002 <== NOT EXECUTED 0010a0fc : int aio_cancel( int filedes, struct aiocb *aiocbp ) { 10a0fc: 55 push %ebp <== NOT EXECUTED 10a0fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a0ff: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a102: e8 79 79 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a107: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a10d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a112: c9 leave <== NOT EXECUTED 10a113: c3 ret <== NOT EXECUTED 0010a114 : #include int aio_error( const struct aiocb *aiocbp ) { 10a114: 55 push %ebp <== NOT EXECUTED 10a115: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a117: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a11a: e8 61 79 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a11f: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a125: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a12a: c9 leave <== NOT EXECUTED 10a12b: c3 ret <== NOT EXECUTED 0010a12c : int aio_fsync( int op, struct aiocb *aiocbp ) { 10a12c: 55 push %ebp <== NOT EXECUTED 10a12d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a12f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a132: e8 49 79 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a137: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a13d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a142: c9 leave <== NOT EXECUTED 10a143: c3 ret <== NOT EXECUTED 0010a144 : #include int aio_read( struct aiocb *aiocbp ) { 10a144: 55 push %ebp <== NOT EXECUTED 10a145: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a147: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a14a: e8 31 79 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a14f: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a155: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a15a: c9 leave <== NOT EXECUTED 10a15b: c3 ret <== NOT EXECUTED 0010a15c : #include int aio_return( const struct aiocb *aiocbp ) { 10a15c: 55 push %ebp <== NOT EXECUTED 10a15d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a15f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a162: e8 19 79 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a167: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a16d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a172: c9 leave <== NOT EXECUTED 10a173: c3 ret <== NOT EXECUTED 0010a174 : int aio_suspend( const struct aiocb * const list[], int nent, const struct timespec *timeout ) { 10a174: 55 push %ebp <== NOT EXECUTED 10a175: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a177: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a17a: e8 01 79 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a17f: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a185: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a18a: c9 leave <== NOT EXECUTED 10a18b: c3 ret <== NOT EXECUTED 0010a18c : #include int aio_write( struct aiocb *aiocbp ) { 10a18c: 55 push %ebp <== NOT EXECUTED 10a18d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a18f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a192: e8 e9 78 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a197: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a19d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a1a2: c9 leave <== NOT EXECUTED 10a1a3: c3 ret <== NOT EXECUTED 0010bc14 : } unsigned int alarm( unsigned int seconds ) { 10bc14: 55 push %ebp <== NOT EXECUTED 10bc15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc17: 53 push %ebx <== NOT EXECUTED 10bc18: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 10bc1b: a1 bc 4f 12 00 mov 0x124fbc,%eax <== NOT EXECUTED 10bc20: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc22: 74 68 je 10bc8c <== NOT EXECUTED _Watchdog_Initialize( the_timer, _POSIX_signals_Alarm_TSR, 0, NULL ); } else { switch ( _Watchdog_Remove( the_timer ) ) { 10bc24: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bc27: 68 a0 4f 12 00 push $0x124fa0 <== NOT EXECUTED 10bc2c: e8 bf 48 00 00 call 1104f0 <_Watchdog_Remove> <== NOT EXECUTED 10bc31: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bc34: 83 e8 02 sub $0x2,%eax <== NOT EXECUTED 10bc37: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10bc3a: 77 4c ja 10bc88 <== NOT EXECUTED * The stop_time and start_time fields are snapshots of ticks since * boot. Since alarm() is dealing in seconds, we must account for * this. */ remaining = the_timer->initial - 10bc3c: 8b 0d b8 4f 12 00 mov 0x124fb8,%ecx <== NOT EXECUTED 10bc42: 2b 0d b4 4f 12 00 sub 0x124fb4,%ecx <== NOT EXECUTED 10bc48: b8 40 42 0f 00 mov $0xf4240,%eax <== NOT EXECUTED 10bc4d: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bc4f: f7 35 60 52 12 00 divl 0x125260 <== NOT EXECUTED 10bc55: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10bc57: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10bc59: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bc5b: f7 f3 div %ebx <== NOT EXECUTED 10bc5d: 8b 1d ac 4f 12 00 mov 0x124fac,%ebx <== NOT EXECUTED 10bc63: 29 c3 sub %eax,%ebx <== NOT EXECUTED * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, 10bc65: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bc68: a3 ac 4f 12 00 mov %eax,0x124fac <== NOT EXECUTED size_t size ); 10bc6d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bc70: 68 a0 4f 12 00 push $0x124fa0 <== NOT EXECUTED 10bc75: 68 70 51 12 00 push $0x125170 <== NOT EXECUTED 10bc7a: e8 41 47 00 00 call 1103c0 <_Watchdog_Insert> <== NOT EXECUTED } _Watchdog_Insert_seconds( the_timer, seconds ); return remaining; } 10bc7f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bc81: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bc84: c9 leave <== NOT EXECUTED 10bc85: c3 ret <== NOT EXECUTED 10bc86: 66 90 xchg %ax,%ax <== NOT EXECUTED */ if ( !the_timer->routine ) { _Watchdog_Initialize( the_timer, _POSIX_signals_Alarm_TSR, 0, NULL ); } else { switch ( _Watchdog_Remove( the_timer ) ) { 10bc88: 31 db xor %ebx,%ebx <== NOT EXECUTED 10bc8a: eb d9 jmp 10bc65 <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10bc8c: c7 05 a8 4f 12 00 00 movl $0x0,0x124fa8 <== NOT EXECUTED 10bc93: 00 00 00 <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10bc96: c7 05 bc 4f 12 00 b8 movl $0x10bcb8,0x124fbc <== NOT EXECUTED 10bc9d: bc 10 00 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10bca0: c7 05 c0 4f 12 00 00 movl $0x0,0x124fc0 <== NOT EXECUTED 10bca7: 00 00 00 <== NOT EXECUTED * the heap 10bcaa: c7 05 c4 4f 12 00 00 movl $0x0,0x124fc4 <== NOT EXECUTED 10bcb1: 00 00 00 <== NOT EXECUTED 10bcb4: 31 db xor %ebx,%ebx <== NOT EXECUTED 10bcb6: eb ad jmp 10bc65 <== NOT EXECUTED 00109f40 : */ int alphasort( const void *d1, const void *d2 ) { 109f40: 55 push %ebp <== NOT EXECUTED 109f41: 89 e5 mov %esp,%ebp <== NOT EXECUTED return(strcmp((*(struct dirent **)d1)->d_name, 109f43: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109f46: 8b 10 mov (%eax),%edx <== NOT EXECUTED 109f48: 83 c2 0c add $0xc,%edx <== NOT EXECUTED 109f4b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 109f4e: 8b 00 mov (%eax),%eax <== NOT EXECUTED 109f50: 83 c0 0c add $0xc,%eax <== NOT EXECUTED 109f53: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 109f56: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED (*(struct dirent **)d2)->d_name)); } 109f59: c9 leave <== NOT EXECUTED int alphasort( const void *d1, const void *d2 ) { return(strcmp((*(struct dirent **)d1)->d_name, 109f5a: e9 15 b8 00 00 jmp 115774 <== NOT EXECUTED 0010e4f4 : ) { register char *cptr; int length; MSBUMP(calloc_calls, 1); 10e4f4: 55 push %ebp <== NOT EXECUTED 10e4f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e4f7: 57 push %edi <== NOT EXECUTED 10e4f8: 53 push %ebx <== NOT EXECUTED 10e4f9: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10e4fc: ff 05 d4 f6 11 00 incl 0x11f6d4 <== NOT EXECUTED length = nelem * elsize; 10e502: 0f af 5d 08 imul 0x8(%ebp),%ebx <== NOT EXECUTED cptr = malloc( length ); 10e506: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e509: 53 push %ebx <== NOT EXECUTED 10e50a: e8 a9 8d ff ff call 1072b8 <== NOT EXECUTED 10e50f: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( cptr ) 10e511: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e514: 85 c0 test %eax,%eax <== NOT EXECUTED 10e516: 74 08 je 10e520 <== NOT EXECUTED memset( cptr, '\0', length ); 10e518: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e51a: 89 d7 mov %edx,%edi <== NOT EXECUTED 10e51c: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10e51e: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED MSBUMP(malloc_calls, -1); /* subtract off the malloc */ 10e520: ff 0d c4 f6 11 00 decl 0x11f6c4 <== NOT EXECUTED return cptr; } 10e526: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e528: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e52b: 5b pop %ebx <== NOT EXECUTED 10e52c: 5f pop %edi <== NOT EXECUTED 10e52d: c9 leave <== NOT EXECUTED 10e52e: c3 ret <== NOT EXECUTED 001233ec : #include int chdir( const char *pathname ) { 1233ec: 55 push %ebp <== NOT EXECUTED 1233ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1233ef: 57 push %edi <== NOT EXECUTED 1233f0: 56 push %esi <== NOT EXECUTED 1233f1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( 1233f4: 6a 01 push $0x1 <== NOT EXECUTED 1233f6: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 1233f9: 56 push %esi <== NOT EXECUTED 1233fa: 6a 01 push $0x1 <== NOT EXECUTED 1233fc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1233ff: e8 28 7e fe ff call 10b22c <== NOT EXECUTED pathname, RTEMS_LIBIO_PERMS_SEARCH, &loc, true ); if ( result != 0 ) 123404: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123407: 85 c0 test %eax,%eax <== NOT EXECUTED 123409: 75 69 jne 123474 <== NOT EXECUTED /* * Verify you can change directory into this node. */ if ( !loc.ops->node_type_h ) { 12340b: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 12340e: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 123411: 85 c0 test %eax,%eax <== NOT EXECUTED 123413: 74 43 je 123458 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 123415: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123418: 56 push %esi <== NOT EXECUTED 123419: ff d0 call *%eax <== NOT EXECUTED 12341b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12341e: 48 dec %eax <== NOT EXECUTED 12341f: 75 5f jne 123480 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTDIR ); } rtems_filesystem_freenode( &rtems_filesystem_current ); 123421: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED 123426: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 123429: 85 d2 test %edx,%edx <== NOT EXECUTED 12342b: 74 18 je 123445 <== NOT EXECUTED 12342d: 8b 52 1c mov 0x1c(%edx),%edx <== NOT EXECUTED 123430: 85 d2 test %edx,%edx <== NOT EXECUTED 123432: 74 11 je 123445 <== NOT EXECUTED 123434: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123437: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 12343a: 50 push %eax <== NOT EXECUTED 12343b: ff d2 call *%edx <== NOT EXECUTED 12343d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123440: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED rtems_filesystem_current = loc; 123445: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 123448: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12344d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 12344f: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 123451: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 123454: 5e pop %esi <== NOT EXECUTED 123455: 5f pop %edi <== NOT EXECUTED 123456: c9 leave <== NOT EXECUTED 123457: c3 ret <== NOT EXECUTED /* * Verify you can change directory into this node. */ if ( !loc.ops->node_type_h ) { rtems_filesystem_freenode( &loc ); 123458: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 12345b: 85 c0 test %eax,%eax <== NOT EXECUTED 12345d: 74 09 je 123468 <== NOT EXECUTED 12345f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123462: 56 push %esi <== NOT EXECUTED 123463: ff d0 call *%eax <== NOT EXECUTED 123465: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 123468: e8 e7 e3 00 00 call 131854 <__errno> <== NOT EXECUTED 12346d: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 123473: 90 nop <== NOT EXECUTED 123474: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED rtems_filesystem_freenode( &rtems_filesystem_current ); rtems_filesystem_current = loc; return 0; } 123479: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12347c: 5e pop %esi <== NOT EXECUTED 12347d: 5f pop %edi <== NOT EXECUTED 12347e: c9 leave <== NOT EXECUTED 12347f: c3 ret <== 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 ); 123480: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 123483: 85 c0 test %eax,%eax <== NOT EXECUTED 123485: 74 10 je 123497 <== NOT EXECUTED 123487: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12348a: 85 c0 test %eax,%eax <== NOT EXECUTED 12348c: 74 09 je 123497 <== NOT EXECUTED 12348e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123491: 56 push %esi <== NOT EXECUTED 123492: ff d0 call *%eax <== NOT EXECUTED 123494: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); 123497: e8 b8 e3 00 00 call 131854 <__errno> <== NOT EXECUTED 12349c: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 1234a2: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1234a7: eb a8 jmp 123451 <== NOT EXECUTED 0010b044 : int chmod( const char *path, mode_t mode ) { 10b044: 55 push %ebp <== NOT EXECUTED 10b045: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b047: 56 push %esi <== NOT EXECUTED 10b048: 53 push %ebx <== NOT EXECUTED 10b049: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED int status; rtems_filesystem_location_info_t loc; int result; status = rtems_filesystem_evaluate_path( path, 0, &loc, true ); 10b04c: 6a 01 push $0x1 <== NOT EXECUTED 10b04e: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 10b051: 56 push %esi <== NOT EXECUTED 10b052: 6a 00 push $0x0 <== NOT EXECUTED 10b054: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b057: e8 d0 01 00 00 call 10b22c <== NOT EXECUTED if ( status != 0 ) 10b05c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b05f: 85 c0 test %eax,%eax <== NOT EXECUTED 10b061: 75 61 jne 10b0c4 <== NOT EXECUTED return -1; if ( !loc.handlers ){ 10b063: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10b066: 85 c0 test %eax,%eax <== NOT EXECUTED 10b068: 74 35 je 10b09f <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( EBADF ); } if ( !loc.handlers->fchmod_h ){ 10b06a: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10b06d: 85 c0 test %eax,%eax <== NOT EXECUTED 10b06f: 74 61 je 10b0d2 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.handlers->fchmod_h)( &loc, mode ); 10b071: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b074: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b077: 56 push %esi <== NOT EXECUTED 10b078: ff d0 call *%eax <== NOT EXECUTED 10b07a: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 10b07c: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10b07f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b082: 85 c0 test %eax,%eax <== NOT EXECUTED 10b084: 74 10 je 10b096 <== NOT EXECUTED 10b086: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10b089: 85 c0 test %eax,%eax <== NOT EXECUTED 10b08b: 74 09 je 10b096 <== NOT EXECUTED 10b08d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b090: 56 push %esi <== NOT EXECUTED 10b091: ff d0 call *%eax <== NOT EXECUTED 10b093: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 10b096: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b098: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b09b: 5b pop %ebx <== NOT EXECUTED 10b09c: 5e pop %esi <== NOT EXECUTED 10b09d: c9 leave <== NOT EXECUTED 10b09e: c3 ret <== NOT EXECUTED status = rtems_filesystem_evaluate_path( path, 0, &loc, true ); if ( status != 0 ) return -1; if ( !loc.handlers ){ rtems_filesystem_freenode( &loc ); 10b09f: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10b0a2: 85 c0 test %eax,%eax <== NOT EXECUTED 10b0a4: 74 10 je 10b0b6 <== NOT EXECUTED 10b0a6: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10b0a9: 85 c0 test %eax,%eax <== NOT EXECUTED 10b0ab: 74 09 je 10b0b6 <== NOT EXECUTED 10b0ad: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b0b0: 56 push %esi <== NOT EXECUTED 10b0b1: ff d0 call *%eax <== NOT EXECUTED 10b0b3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); 10b0b6: e8 99 67 02 00 call 131854 <__errno> <== NOT EXECUTED 10b0bb: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10b0c1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10b0c4: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED result = (*loc.handlers->fchmod_h)( &loc, mode ); rtems_filesystem_freenode( &loc ); return result; } 10b0c9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b0cb: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b0ce: 5b pop %ebx <== NOT EXECUTED 10b0cf: 5e pop %esi <== NOT EXECUTED 10b0d0: c9 leave <== NOT EXECUTED 10b0d1: c3 ret <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( EBADF ); } if ( !loc.handlers->fchmod_h ){ rtems_filesystem_freenode( &loc ); 10b0d2: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10b0d5: 85 c0 test %eax,%eax <== NOT EXECUTED 10b0d7: 74 10 je 10b0e9 <== NOT EXECUTED 10b0d9: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10b0dc: 85 c0 test %eax,%eax <== NOT EXECUTED 10b0de: 74 09 je 10b0e9 <== NOT EXECUTED 10b0e0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b0e3: 56 push %esi <== NOT EXECUTED 10b0e4: ff d0 call *%eax <== NOT EXECUTED 10b0e6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 10b0e9: e8 66 67 02 00 call 131854 <__errno> <== NOT EXECUTED 10b0ee: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10b0f4: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10b0f9: eb 9b jmp 10b096 <== NOT EXECUTED 001234ac : int chown( const char *path, uid_t owner, gid_t group ) { 1234ac: 55 push %ebp <== NOT EXECUTED 1234ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1234af: 57 push %edi <== NOT EXECUTED 1234b0: 56 push %esi <== NOT EXECUTED 1234b1: 53 push %ebx <== NOT EXECUTED 1234b2: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1234b5: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 1234b8: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_filesystem_location_info_t loc; int result; if ( rtems_filesystem_evaluate_path( path, 0x00, &loc, true ) ) 1234bb: 6a 01 push $0x1 <== NOT EXECUTED 1234bd: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 1234c0: 56 push %esi <== NOT EXECUTED 1234c1: 6a 00 push $0x0 <== NOT EXECUTED 1234c3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1234c6: e8 61 7d fe ff call 10b22c <== NOT EXECUTED 1234cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1234ce: 85 c0 test %eax,%eax <== NOT EXECUTED 1234d0: 75 5a jne 12352c <== NOT EXECUTED return -1; if ( !loc.ops->chown_h ) { 1234d2: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1234d5: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED 1234d8: 85 d2 test %edx,%edx <== NOT EXECUTED 1234da: 74 32 je 12350e <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->chown_h)( &loc, owner, group ); 1234dc: 50 push %eax <== NOT EXECUTED 1234dd: 0f b7 c3 movzwl %bx,%eax <== NOT EXECUTED 1234e0: 50 push %eax <== NOT EXECUTED 1234e1: 0f b7 c7 movzwl %di,%eax <== NOT EXECUTED 1234e4: 50 push %eax <== NOT EXECUTED 1234e5: 56 push %esi <== NOT EXECUTED 1234e6: ff d2 call *%edx <== NOT EXECUTED 1234e8: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1234ea: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1234ed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1234f0: 85 c0 test %eax,%eax <== NOT EXECUTED 1234f2: 74 10 je 123504 <== NOT EXECUTED 1234f4: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1234f7: 85 c0 test %eax,%eax <== NOT EXECUTED 1234f9: 74 09 je 123504 <== NOT EXECUTED 1234fb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1234fe: 56 push %esi <== NOT EXECUTED 1234ff: ff d0 call *%eax <== NOT EXECUTED 123501: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 123504: 89 d8 mov %ebx,%eax <== NOT EXECUTED 123506: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 123509: 5b pop %ebx <== NOT EXECUTED 12350a: 5e pop %esi <== NOT EXECUTED 12350b: 5f pop %edi <== NOT EXECUTED 12350c: c9 leave <== NOT EXECUTED 12350d: c3 ret <== NOT EXECUTED if ( rtems_filesystem_evaluate_path( path, 0x00, &loc, true ) ) return -1; if ( !loc.ops->chown_h ) { rtems_filesystem_freenode( &loc ); 12350e: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 123511: 85 c0 test %eax,%eax <== NOT EXECUTED 123513: 74 09 je 12351e <== NOT EXECUTED 123515: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123518: 56 push %esi <== NOT EXECUTED 123519: ff d0 call *%eax <== NOT EXECUTED 12351b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 12351e: e8 31 e3 00 00 call 131854 <__errno> <== NOT EXECUTED 123523: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 123529: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 12352c: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED result = (*loc.ops->chown_h)( &loc, owner, group ); rtems_filesystem_freenode( &loc ); return result; } 123531: 89 d8 mov %ebx,%eax <== NOT EXECUTED 123533: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 123536: 5b pop %ebx <== NOT EXECUTED 123537: 5e pop %esi <== NOT EXECUTED 123538: 5f pop %edi <== NOT EXECUTED 123539: c9 leave <== NOT EXECUTED 12353a: c3 ret <== NOT EXECUTED 0012353c : #include int chroot( const char *pathname ) { 12353c: 55 push %ebp <== NOT EXECUTED 12353d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12353f: 57 push %edi <== NOT EXECUTED 123540: 56 push %esi <== NOT EXECUTED 123541: 53 push %ebx <== NOT EXECUTED 123542: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 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) { 123545: 81 3d ec ba 14 00 40 cmpl $0x162640,0x14baec <== NOT EXECUTED 12354c: 26 16 00 <== NOT EXECUTED 12354f: 74 63 je 1235b4 <== NOT EXECUTED 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); 123551: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123554: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 123557: e8 90 fe ff ff call 1233ec <== NOT EXECUTED if (result) { 12355c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12355f: 85 c0 test %eax,%eax <== NOT EXECUTED 123561: 75 75 jne 1235d8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( errno ); } /* clone the new root location */ if (rtems_filesystem_evaluate_path(".", 0, &loc, 0)) { 123563: 6a 00 push $0x0 <== NOT EXECUTED 123565: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 123568: 56 push %esi <== NOT EXECUTED 123569: 6a 00 push $0x0 <== NOT EXECUTED 12356b: 68 b0 27 14 00 push $0x1427b0 <== NOT EXECUTED 123570: e8 b7 7c fe ff call 10b22c <== NOT EXECUTED 123575: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123578: 85 c0 test %eax,%eax <== NOT EXECUTED 12357a: 75 5c jne 1235d8 <== NOT EXECUTED /* 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); 12357c: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED 123581: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 123584: 85 d2 test %edx,%edx <== NOT EXECUTED 123586: 74 18 je 1235a0 <== NOT EXECUTED 123588: 8b 52 1c mov 0x1c(%edx),%edx <== NOT EXECUTED 12358b: 85 d2 test %edx,%edx <== NOT EXECUTED 12358d: 74 11 je 1235a0 <== NOT EXECUTED 12358f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123592: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 123595: 50 push %eax <== NOT EXECUTED 123596: ff d2 call *%edx <== NOT EXECUTED 123598: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12359b: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED rtems_filesystem_root = loc; 1235a0: 8d 78 14 lea 0x14(%eax),%edi <== NOT EXECUTED 1235a3: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1235a8: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1235aa: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 1235ac: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1235af: 5b pop %ebx <== NOT EXECUTED 1235b0: 5e pop %esi <== NOT EXECUTED 1235b1: 5f pop %edi <== NOT EXECUTED 1235b2: c9 leave <== NOT EXECUTED 1235b3: c3 ret <== NOT EXECUTED 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*/ 1235b4: e8 fb 19 00 00 call 124fb4 <== NOT EXECUTED if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 1235b9: 81 3d ec ba 14 00 40 cmpl $0x162640,0x14baec <== NOT EXECUTED 1235c0: 26 16 00 <== NOT EXECUTED 1235c3: 75 8c jne 123551 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1235c5: e8 8a e2 00 00 call 131854 <__errno> <== NOT EXECUTED 1235ca: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1235d0: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1235d5: eb d5 jmp 1235ac <== NOT EXECUTED 1235d7: 90 nop <== NOT EXECUTED } /* 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 ); 1235d8: e8 77 e2 00 00 call 131854 <__errno> <== NOT EXECUTED 1235dd: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1235df: e8 70 e2 00 00 call 131854 <__errno> <== NOT EXECUTED 1235e4: 8b 00 mov (%eax),%eax <== NOT EXECUTED 1235e6: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 1235e8: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1235ed: eb bd jmp 1235ac <== NOT EXECUTED 0010a1a4 : int clock_getcpuclockid( pid_t pid, clockid_t *clock_id ) { 10a1a4: 55 push %ebp <== NOT EXECUTED 10a1a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a1a7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a1aa: e8 d1 78 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a1af: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a1b5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a1ba: c9 leave <== NOT EXECUTED 10a1bb: c3 ret <== NOT EXECUTED 0010a1bc : int clock_getenable_attr( clockid_t clock_id, int *attr ) { 10a1bc: 55 push %ebp <== NOT EXECUTED 10a1bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a1bf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a1c2: e8 b9 78 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a1c7: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a1cd: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a1d2: c9 leave <== NOT EXECUTED 10a1d3: c3 ret <== NOT EXECUTED 0010aa48 : int clock_getres( clockid_t clock_id, struct timespec *res ) { 10aa48: 55 push %ebp <== NOT EXECUTED 10aa49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa4b: 53 push %ebx <== NOT EXECUTED 10aa4c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10aa4f: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED if ( !res ) 10aa52: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10aa54: 74 32 je 10aa88 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); switch ( clock_id ) { 10aa56: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10aa59: 48 dec %eax <== NOT EXECUTED 10aa5a: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10aa5d: 77 29 ja 10aa88 <== NOT EXECUTED case CLOCK_REALTIME: case CLOCK_PROCESS_CPUTIME: case CLOCK_THREAD_CPUTIME: if ( res ) { res->tv_sec = _TOD_Microseconds_per_tick / 1000000; 10aa5f: 8b 1d 80 35 12 00 mov 0x123580,%ebx <== NOT EXECUTED 10aa65: ba 83 de 1b 43 mov $0x431bde83,%edx <== NOT EXECUTED 10aa6a: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10aa6c: f7 e2 mul %edx <== NOT EXECUTED 10aa6e: c1 ea 12 shr $0x12,%edx <== NOT EXECUTED 10aa71: 89 11 mov %edx,(%ecx) <== NOT EXECUTED res->tv_nsec = _TOD_Microseconds_per_tick * 1000; 10aa73: 8d 04 9b lea (%ebx,%ebx,4),%eax <== NOT EXECUTED 10aa76: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10aa79: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10aa7c: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 10aa7f: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED 10aa82: 31 c0 xor %eax,%eax <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( EINVAL ); } return 0; } 10aa84: 5a pop %edx <== NOT EXECUTED 10aa85: 5b pop %ebx <== NOT EXECUTED 10aa86: c9 leave <== NOT EXECUTED 10aa87: c3 ret <== NOT EXECUTED /* _TOD_From_ticks( _TOD_Microseconds_per_tick, res ); */ } break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10aa88: e8 53 7b 00 00 call 1125e0 <__errno> <== NOT EXECUTED 10aa8d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10aa93: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10aa98: eb ea jmp 10aa84 <== NOT EXECUTED 0010aa9c : int clock_gettime( clockid_t clock_id, struct timespec *tp ) { 10aa9c: 55 push %ebp <== NOT EXECUTED 10aa9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa9f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10aaa2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10aaa5: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !tp ) 10aaa8: 85 d2 test %edx,%edx <== NOT EXECUTED 10aaaa: 74 14 je 10aac0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) 10aaac: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10aaaf: 74 47 je 10aaf8 <== NOT EXECUTED _TOD_Get(tp); #ifdef CLOCK_MONOTONIC else if ( clock_id == CLOCK_MONOTONIC ) 10aab1: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10aab4: 74 1e je 10aad4 <== NOT EXECUTED _TOD_Get_uptime(tp); #endif #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 10aab6: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10aab9: 74 19 je 10aad4 <== NOT EXECUTED _TOD_Get_uptime(tp); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 10aabb: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10aabe: 74 24 je 10aae4 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 10aac0: e8 1b 7b 00 00 call 1125e0 <__errno> <== NOT EXECUTED 10aac5: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10aacb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED return 0; } 10aad0: c9 leave <== NOT EXECUTED 10aad1: c3 ret <== NOT EXECUTED 10aad2: 66 90 xchg %ax,%ax <== NOT EXECUTED else if ( clock_id == CLOCK_MONOTONIC ) _TOD_Get_uptime(tp); #endif #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) _TOD_Get_uptime(tp); 10aad4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aad7: 52 push %edx <== NOT EXECUTED 10aad8: e8 df 23 00 00 call 10cebc <_TOD_Get_uptime> <== NOT EXECUTED 10aadd: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aadf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 10aae2: c9 leave <== NOT EXECUTED 10aae3: c3 ret <== NOT EXECUTED else if ( clock_id == CLOCK_PROCESS_CPUTIME ) _TOD_Get_uptime(tp); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) rtems_set_errno_and_return_minus_one( ENOSYS ); 10aae4: e8 f7 7a 00 00 call 1125e0 <__errno> <== NOT EXECUTED 10aae9: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED 10aaef: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 10aaf4: c9 leave <== NOT EXECUTED 10aaf5: c3 ret <== NOT EXECUTED 10aaf6: 66 90 xchg %ax,%ax <== NOT EXECUTED { if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) _TOD_Get(tp); 10aaf8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aafb: 52 push %edx <== NOT EXECUTED 10aafc: e8 67 23 00 00 call 10ce68 <_TOD_Get> <== NOT EXECUTED 10ab01: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ab03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 10ab06: c9 leave <== NOT EXECUTED 10ab07: c3 ret <== NOT EXECUTED 0010a240 : int clock_setenable_attr( clockid_t clock_id, int attr ) { 10a240: 55 push %ebp <== NOT EXECUTED 10a241: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a243: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a246: e8 35 78 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a24b: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a251: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a256: c9 leave <== NOT EXECUTED 10a257: c3 ret <== NOT EXECUTED 00125870 : int clock_settime( clockid_t clock_id, const struct timespec *tp ) { 125870: 55 push %ebp <== NOT EXECUTED 125871: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125873: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 125876: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 125879: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !tp ) 12587c: 85 d2 test %edx,%edx <== NOT EXECUTED 12587e: 74 0f je 12588f <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { 125880: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 125883: 74 33 je 1258b8 <== NOT EXECUTED _Thread_Disable_dispatch(); _TOD_Set( tp ); _Thread_Enable_dispatch(); } #ifdef _POSIX_CPUTIME else if ( clock_id == CLOCK_PROCESS_CPUTIME ) 125885: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 125888: 74 1a je 1258a4 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) 12588a: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 12588d: 74 15 je 1258a4 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); #endif else rtems_set_errno_and_return_minus_one( EINVAL ); 12588f: e8 c0 bf 00 00 call 131854 <__errno> <== NOT EXECUTED 125894: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 12589a: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED return 0; } 12589f: c9 leave <== NOT EXECUTED 1258a0: c3 ret <== NOT EXECUTED 1258a1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED else if ( clock_id == CLOCK_PROCESS_CPUTIME ) rtems_set_errno_and_return_minus_one( ENOSYS ); #endif #ifdef _POSIX_THREAD_CPUTIME else if ( clock_id == CLOCK_THREAD_CPUTIME ) rtems_set_errno_and_return_minus_one( ENOSYS ); 1258a4: e8 ab bf 00 00 call 131854 <__errno> <== NOT EXECUTED 1258a9: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED 1258af: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 1258b4: c9 leave <== NOT EXECUTED 1258b5: c3 ret <== NOT EXECUTED 1258b6: 66 90 xchg %ax,%ax <== NOT EXECUTED { if ( !tp ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( clock_id == CLOCK_REALTIME ) { if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) 1258b8: 81 3a ff e4 da 21 cmpl $0x21dae4ff,(%edx) <== NOT EXECUTED 1258be: 76 cf jbe 12588f <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1258c0: a1 f8 1e 16 00 mov 0x161ef8,%eax <== NOT EXECUTED 1258c5: 40 inc %eax <== NOT EXECUTED 1258c6: a3 f8 1e 16 00 mov %eax,0x161ef8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); _Thread_Disable_dispatch(); _TOD_Set( tp ); 1258cb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1258ce: 52 push %edx <== NOT EXECUTED 1258cf: e8 00 15 00 00 call 126dd4 <_TOD_Set> <== NOT EXECUTED _Thread_Enable_dispatch(); 1258d4: e8 9f be fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 1258d9: 31 c0 xor %eax,%eax <== NOT EXECUTED 1258db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif else rtems_set_errno_and_return_minus_one( EINVAL ); return 0; } 1258de: c9 leave <== NOT EXECUTED 1258df: c3 ret <== NOT EXECUTED 0010e530 : #include int close( int fd ) { 10e530: 55 push %ebp <== NOT EXECUTED 10e531: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e533: 56 push %esi <== NOT EXECUTED 10e534: 53 push %ebx <== NOT EXECUTED 10e535: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED rtems_libio_t *iop; rtems_status_code rc; rtems_libio_check_fd(fd); 10e538: 3b 15 00 b1 11 00 cmp 0x11b100,%edx <== NOT EXECUTED 10e53e: 73 64 jae 10e5a4 <== NOT EXECUTED iop = rtems_libio_iop(fd); 10e540: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10e543: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 10e546: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 10e54d: 03 1d 30 f6 11 00 add 0x11f630,%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 10e553: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 10e557: 74 4b je 10e5a4 <== NOT EXECUTED rc = RTEMS_SUCCESSFUL; if ( iop->handlers->close_h ) 10e559: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10e55c: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10e55f: 85 c0 test %eax,%eax <== NOT EXECUTED 10e561: 74 3d je 10e5a0 <== NOT EXECUTED rc = (*iop->handlers->close_h)( iop ); 10e563: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e566: 53 push %ebx <== NOT EXECUTED 10e567: ff d0 call *%eax <== NOT EXECUTED 10e569: 89 c6 mov %eax,%esi <== NOT EXECUTED 10e56b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &iop->pathinfo ); 10e56e: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10e571: 85 c0 test %eax,%eax <== NOT EXECUTED 10e573: 74 13 je 10e588 <== NOT EXECUTED 10e575: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 10e578: 85 d2 test %edx,%edx <== NOT EXECUTED 10e57a: 74 0c je 10e588 <== NOT EXECUTED 10e57c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e57f: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10e582: 50 push %eax <== NOT EXECUTED 10e583: ff d2 call *%edx <== NOT EXECUTED 10e585: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_libio_free( iop ); 10e588: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e58b: 53 push %ebx <== NOT EXECUTED 10e58c: e8 9b 02 00 00 call 10e82c <== NOT EXECUTED 10e591: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return rc; } 10e594: 89 f0 mov %esi,%eax <== NOT EXECUTED 10e596: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e599: 5b pop %ebx <== NOT EXECUTED 10e59a: 5e pop %esi <== NOT EXECUTED 10e59b: c9 leave <== NOT EXECUTED 10e59c: c3 ret <== NOT EXECUTED 10e59d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED rtems_libio_check_fd(fd); iop = rtems_libio_iop(fd); rtems_libio_check_is_open(iop); rc = RTEMS_SUCCESSFUL; if ( iop->handlers->close_h ) 10e5a0: 31 f6 xor %esi,%esi <== NOT EXECUTED 10e5a2: eb ca jmp 10e56e <== NOT EXECUTED rtems_libio_t *iop; rtems_status_code rc; rtems_libio_check_fd(fd); iop = rtems_libio_iop(fd); rtems_libio_check_is_open(iop); 10e5a4: e8 d7 26 00 00 call 110c80 <__errno> <== NOT EXECUTED 10e5a9: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10e5af: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 10e5b4: eb de jmp 10e594 <== NOT EXECUTED 0012f7c0 : * close a directory. */ int closedir( DIR *dirp ) { 12f7c0: 55 push %ebp <== NOT EXECUTED 12f7c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f7c3: 56 push %esi <== NOT EXECUTED 12f7c4: 53 push %ebx <== NOT EXECUTED 12f7c5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED int fd; if ( !dirp ) 12f7c8: 85 f6 test %esi,%esi <== NOT EXECUTED 12f7ca: 74 33 je 12f7ff <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); fd = dirp->dd_fd; 12f7cc: 8b 1e mov (%esi),%ebx <== NOT EXECUTED dirp->dd_fd = -1; 12f7ce: c7 06 ff ff ff ff movl $0xffffffff,(%esi) <== NOT EXECUTED dirp->dd_loc = 0; 12f7d4: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) <== NOT EXECUTED (void)free((void *)dirp->dd_buf); 12f7db: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12f7de: ff 76 0c pushl 0xc(%esi) <== NOT EXECUTED 12f7e1: e8 8a bb fd ff call 10b370 <== NOT EXECUTED (void)free((void *)dirp); 12f7e6: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 12f7e9: e8 82 bb fd ff call 10b370 <== NOT EXECUTED return(close(fd)); 12f7ee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12f7f1: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 12f7f4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12f7f7: 5b pop %ebx <== NOT EXECUTED 12f7f8: 5e pop %esi <== NOT EXECUTED 12f7f9: c9 leave <== NOT EXECUTED fd = dirp->dd_fd; dirp->dd_fd = -1; dirp->dd_loc = 0; (void)free((void *)dirp->dd_buf); (void)free((void *)dirp); return(close(fd)); 12f7fa: e9 fd b8 fd ff jmp 10b0fc <== NOT EXECUTED DIR *dirp ) { int fd; if ( !dirp ) rtems_set_errno_and_return_minus_one( EBADF ); 12f7ff: e8 50 20 00 00 call 131854 <__errno> <== NOT EXECUTED 12f804: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED dirp->dd_fd = -1; dirp->dd_loc = 0; (void)free((void *)dirp->dd_buf); (void)free((void *)dirp); return(close(fd)); } 12f80a: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12f80f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12f812: 5b pop %ebx <== NOT EXECUTED 12f813: 5e pop %esi <== NOT EXECUTED 12f814: c9 leave <== NOT EXECUTED 12f815: c3 ret <== NOT EXECUTED 0010a2c8 : int filedes, void *dev_data_ptr, size_t nbyte, int *dev_info_ptr ) { 10a2c8: 55 push %ebp <== NOT EXECUTED 10a2c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a2cb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a2ce: e8 ad 77 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a2d3: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a2d9: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a2de: c9 leave <== NOT EXECUTED 10a2df: c3 ret <== NOT EXECUTED 00110120 : */ int device_close( rtems_libio_t *iop ) { 110120: 55 push %ebp <== NOT EXECUTED 110121: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110123: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 110126: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED rtems_libio_open_close_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 110129: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED args.iop = iop; 11012c: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = 0; 11012f: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%ebp) <== NOT EXECUTED args.mode = 0; 110136: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_close( 11013d: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 110140: 50 push %eax <== NOT EXECUTED 110141: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED 110144: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED 110147: e8 98 07 00 00 call 1108e4 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) { 11014c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11014f: 85 c0 test %eax,%eax <== NOT EXECUTED 110151: 75 05 jne 110158 <== NOT EXECUTED return rtems_deviceio_errno(status); } return 0; } 110153: c9 leave <== NOT EXECUTED 110154: c3 ret <== NOT EXECUTED 110155: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) { return rtems_deviceio_errno(status); 110158: e8 af fe ff ff call 11000c <== NOT EXECUTED } return 0; } 11015d: c9 leave <== NOT EXECUTED 11015e: c3 ret <== NOT EXECUTED 00110004 : int device_ftruncate( rtems_libio_t *iop, off_t length ) { 110004: 55 push %ebp <== NOT EXECUTED 110005: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 110007: 31 c0 xor %eax,%eax <== NOT EXECUTED 110009: c9 leave <== NOT EXECUTED 11000a: c3 ret <== NOT EXECUTED 00110038 : int device_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 110038: 55 push %ebp <== NOT EXECUTED 110039: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11003b: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 11003e: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED rtems_libio_ioctl_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; args.iop = iop; 110041: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED args.command = command; 110044: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 110047: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.buffer = buffer; 11004a: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11004d: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED the_jnode = iop->file_info; 110050: 8b 52 2c mov 0x2c(%edx),%edx <== NOT EXECUTED status = rtems_io_control( 110053: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 110056: 50 push %eax <== NOT EXECUTED 110057: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED 11005a: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED 11005d: e8 c2 08 00 00 call 110924 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 110062: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110065: 85 c0 test %eax,%eax <== NOT EXECUTED 110067: 75 07 jne 110070 <== NOT EXECUTED return rtems_deviceio_errno(status); return args.ioctl_return; 110069: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 11006c: c9 leave <== NOT EXECUTED 11006d: c3 ret <== NOT EXECUTED 11006e: 66 90 xchg %ax,%ax <== NOT EXECUTED the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 110070: e8 97 ff ff ff call 11000c <== NOT EXECUTED return args.ioctl_return; } 110075: c9 leave <== NOT EXECUTED 110076: c3 ret <== NOT EXECUTED 0010fffc : off_t device_lseek( rtems_libio_t *iop, off_t offset, int whence ) { 10fffc: 55 push %ebp <== NOT EXECUTED 10fffd: 89 e5 mov %esp,%ebp <== NOT EXECUTED return offset; } 10ffff: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 110002: c9 leave <== NOT EXECUTED 110003: c3 ret <== NOT EXECUTED 00110160 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 110160: 55 push %ebp <== NOT EXECUTED 110161: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110163: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 110166: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED rtems_libio_open_close_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 110169: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED args.iop = iop; 11016c: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = iop->flags; 11016f: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 110172: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED args.mode = mode; 110175: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 110178: 89 45 fc mov %eax,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_open( 11017b: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 11017e: 50 push %eax <== NOT EXECUTED 11017f: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED 110182: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED 110185: e8 da 07 00 00 call 110964 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 11018a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11018d: 85 c0 test %eax,%eax <== NOT EXECUTED 11018f: 75 03 jne 110194 <== NOT EXECUTED return rtems_deviceio_errno(status); return 0; } 110191: c9 leave <== NOT EXECUTED 110192: c3 ret <== NOT EXECUTED 110193: 90 nop <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 110194: e8 73 fe ff ff call 11000c <== NOT EXECUTED return 0; } 110199: c9 leave <== NOT EXECUTED 11019a: c3 ret <== NOT EXECUTED 001100cc : ssize_t device_read( rtems_libio_t *iop, void *buffer, size_t count ) { 1100cc: 55 push %ebp <== NOT EXECUTED 1100cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1100cf: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 1100d2: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED rtems_libio_rw_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 1100d5: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED args.iop = iop; 1100d8: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED args.offset = iop->offset; 1100db: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 1100de: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED args.buffer = buffer; 1100e1: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1100e4: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED args.count = count; 1100e7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1100ea: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = iop->flags; 1100ed: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 1100f0: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED args.bytes_moved = 0; 1100f3: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_read( 1100fa: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 1100fd: 50 push %eax <== NOT EXECUTED 1100fe: ff 71 54 pushl 0x54(%ecx) <== NOT EXECUTED 110101: ff 71 50 pushl 0x50(%ecx) <== NOT EXECUTED 110104: e8 9b 08 00 00 call 1109a4 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 110109: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11010c: 85 c0 test %eax,%eax <== NOT EXECUTED 11010e: 75 08 jne 110118 <== NOT EXECUTED return rtems_deviceio_errno(status); return (ssize_t) args.bytes_moved; 110110: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 110113: c9 leave <== NOT EXECUTED 110114: c3 ret <== NOT EXECUTED 110115: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 110118: e8 ef fe ff ff call 11000c <== NOT EXECUTED return (ssize_t) args.bytes_moved; } 11011d: c9 leave <== NOT EXECUTED 11011e: c3 ret <== NOT EXECUTED 00110078 : ssize_t device_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 110078: 55 push %ebp <== NOT EXECUTED 110079: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11007b: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 11007e: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED rtems_libio_rw_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 110081: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED args.iop = iop; 110084: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED args.offset = iop->offset; 110087: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 11008a: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED args.buffer = (void *) buffer; 11008d: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 110090: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED args.count = count; 110093: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 110096: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = iop->flags; 110099: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 11009c: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED args.bytes_moved = 0; 11009f: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_write( 1100a6: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 1100a9: 50 push %eax <== NOT EXECUTED 1100aa: ff 71 54 pushl 0x54(%ecx) <== NOT EXECUTED 1100ad: ff 71 50 pushl 0x50(%ecx) <== NOT EXECUTED 1100b0: e8 2f 09 00 00 call 1109e4 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 1100b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1100b8: 85 c0 test %eax,%eax <== NOT EXECUTED 1100ba: 75 08 jne 1100c4 <== NOT EXECUTED return rtems_deviceio_errno(status); return (ssize_t) args.bytes_moved; 1100bc: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 1100bf: c9 leave <== NOT EXECUTED 1100c0: c3 ret <== NOT EXECUTED 1100c1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 1100c4: e8 43 ff ff ff call 11000c <== NOT EXECUTED return (ssize_t) args.bytes_moved; } 1100c9: c9 leave <== NOT EXECUTED 1100ca: c3 ret <== NOT EXECUTED 00108c10 : /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty) { 108c10: 55 push %ebp <== NOT EXECUTED 108c11: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108c13: 53 push %ebx <== NOT EXECUTED 108c14: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 108c17: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { 108c19: 8b 80 b4 00 00 00 mov 0xb4(%eax),%eax <== NOT EXECUTED 108c1f: 85 c0 test %eax,%eax <== NOT EXECUTED 108c21: 74 4d je 108c70 <== NOT EXECUTED rtems_interrupt_disable (level); 108c23: 9c pushf <== NOT EXECUTED 108c24: fa cli <== NOT EXECUTED 108c25: 59 pop %ecx <== NOT EXECUTED while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { 108c26: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx <== NOT EXECUTED 108c2c: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax <== NOT EXECUTED 108c32: 39 c2 cmp %eax,%edx <== NOT EXECUTED 108c34: 74 38 je 108c6e <== NOT EXECUTED 108c36: 66 90 xchg %ax,%ax <== NOT EXECUTED tty->rawOutBufState = rob_wait; 108c38: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) <== NOT EXECUTED 108c3f: 00 00 00 <== NOT EXECUTED rtems_interrupt_enable (level); 108c42: 51 push %ecx <== NOT EXECUTED 108c43: 9d popf <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, 108c44: 50 push %eax <== NOT EXECUTED 108c45: 6a 00 push $0x0 <== NOT EXECUTED 108c47: 6a 00 push $0x0 <== NOT EXECUTED 108c49: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED 108c4f: e8 58 17 00 00 call 10a3ac <== NOT EXECUTED RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 108c54: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108c57: 85 c0 test %eax,%eax <== NOT EXECUTED 108c59: 75 1d jne 108c78 <== NOT EXECUTED rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); 108c5b: 9c pushf <== NOT EXECUTED 108c5c: fa cli <== NOT EXECUTED 108c5d: 59 pop %ecx <== 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) { 108c5e: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx <== NOT EXECUTED 108c64: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax <== NOT EXECUTED 108c6a: 39 c2 cmp %eax,%edx <== NOT EXECUTED 108c6c: 75 ca jne 108c38 <== NOT EXECUTED RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } rtems_interrupt_enable (level); 108c6e: 51 push %ecx <== NOT EXECUTED 108c6f: 9d popf <== NOT EXECUTED } } 108c70: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 108c73: c9 leave <== NOT EXECUTED 108c74: c3 ret <== NOT EXECUTED 108c75: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED rtems_interrupt_enable (level); sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); 108c78: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108c7b: 50 push %eax <== NOT EXECUTED 108c7c: e8 c7 1d 00 00 call 10aa48 <== NOT EXECUTED 00107ce8 : #include int dup( int fildes ) { 107ce8: 55 push %ebp <== NOT EXECUTED 107ce9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107ceb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return fcntl( fildes, F_DUPFD, 0 ); 107cee: 6a 00 push $0x0 <== NOT EXECUTED 107cf0: 6a 00 push $0x0 <== NOT EXECUTED 107cf2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107cf5: e8 de 01 00 00 call 107ed8 <== NOT EXECUTED } 107cfa: c9 leave <== NOT EXECUTED 107cfb: c3 ret <== NOT EXECUTED 00107c9c : int dup2( int fildes, int fildes2 ) { 107c9c: 55 push %ebp <== NOT EXECUTED 107c9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107c9f: 56 push %esi <== NOT EXECUTED 107ca0: 53 push %ebx <== NOT EXECUTED 107ca1: 83 ec 58 sub $0x58,%esp <== NOT EXECUTED 107ca4: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED /* * If fildes is not valid, then fildes2 should not be closed. */ status = fstat( fildes, &buf ); 107ca7: 8d 5d ac lea -0x54(%ebp),%ebx <== NOT EXECUTED 107caa: 53 push %ebx <== NOT EXECUTED 107cab: 56 push %esi <== NOT EXECUTED 107cac: e8 d3 05 00 00 call 108284 <== NOT EXECUTED if ( status == -1 ) 107cb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107cb4: 40 inc %eax <== NOT EXECUTED 107cb5: 75 0d jne 107cc4 <== NOT EXECUTED /* * This fcntl handles everything else. */ return fcntl( fildes, F_DUPFD, fildes2 ); 107cb7: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 107cbc: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 107cbf: 5b pop %ebx <== NOT EXECUTED 107cc0: 5e pop %esi <== NOT EXECUTED 107cc1: c9 leave <== NOT EXECUTED 107cc2: c3 ret <== NOT EXECUTED 107cc3: 90 nop <== NOT EXECUTED /* * If fildes2 is not valid, then we should not do anything either. */ status = fstat( fildes2, &buf ); 107cc4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107cc7: 53 push %ebx <== NOT EXECUTED 107cc8: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 107ccb: e8 b4 05 00 00 call 108284 <== NOT EXECUTED if ( status == -1 ) 107cd0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107cd3: 40 inc %eax <== NOT EXECUTED 107cd4: 74 e1 je 107cb7 <== NOT EXECUTED /* * This fcntl handles everything else. */ return fcntl( fildes, F_DUPFD, fildes2 ); 107cd6: 50 push %eax <== NOT EXECUTED 107cd7: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 107cda: 6a 00 push $0x0 <== NOT EXECUTED 107cdc: 56 push %esi <== NOT EXECUTED 107cdd: e8 f6 01 00 00 call 107ed8 <== NOT EXECUTED 107ce2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107ce5: eb d5 jmp 107cbc <== NOT EXECUTED 001087ac : /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { 1087ac: 55 push %ebp <== NOT EXECUTED 1087ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1087af: 53 push %ebx <== NOT EXECUTED 1087b0: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 1087b3: 89 d3 mov %edx,%ebx <== NOT EXECUTED 1087b5: 88 c1 mov %al,%cl <== NOT EXECUTED if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) { 1087b7: f6 42 3d 02 testb $0x2,0x3d(%edx) <== NOT EXECUTED 1087bb: 74 0e je 1087cb <== NOT EXECUTED 1087bd: 0f b6 d0 movzbl %al,%edx <== NOT EXECUTED 1087c0: a1 34 d6 11 00 mov 0x11d634,%eax <== NOT EXECUTED 1087c5: f6 04 10 20 testb $0x20,(%eax,%edx,1) <== NOT EXECUTED 1087c9: 75 11 jne 1087dc <== NOT EXECUTED echobuf[1] = c ^ 0x40; rtems_termios_puts (echobuf, 2, tty); tty->column += 2; } else { oproc (c, tty); 1087cb: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 1087ce: 89 da mov %ebx,%edx <== NOT EXECUTED 1087d0: e8 a7 fe ff ff call 10867c <== NOT EXECUTED } } 1087d5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1087d8: c9 leave <== NOT EXECUTED 1087d9: c3 ret <== NOT EXECUTED 1087da: 66 90 xchg %ax,%ax <== NOT EXECUTED * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) { 1087dc: 80 f9 09 cmp $0x9,%cl <== NOT EXECUTED 1087df: 74 ea je 1087cb <== NOT EXECUTED 1087e1: 80 f9 0a cmp $0xa,%cl <== NOT EXECUTED 1087e4: 74 e5 je 1087cb <== NOT EXECUTED char echobuf[2]; echobuf[0] = '^'; 1087e6: c6 45 fa 5e movb $0x5e,-0x6(%ebp) <== NOT EXECUTED echobuf[1] = c ^ 0x40; 1087ea: 83 f1 40 xor $0x40,%ecx <== NOT EXECUTED 1087ed: 88 4d fb mov %cl,-0x5(%ebp) <== NOT EXECUTED rtems_termios_puts (echobuf, 2, tty); 1087f0: 50 push %eax <== NOT EXECUTED 1087f1: 53 push %ebx <== NOT EXECUTED 1087f2: 6a 02 push $0x2 <== NOT EXECUTED 1087f4: 8d 45 fa lea -0x6(%ebp),%eax <== NOT EXECUTED 1087f7: 50 push %eax <== NOT EXECUTED 1087f8: e8 4f fd ff ff call 10854c <== NOT EXECUTED tty->column += 2; 1087fd: 83 43 28 02 addl $0x2,0x28(%ebx) <== NOT EXECUTED 108801: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { oproc (c, tty); } } 108804: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 108807: c9 leave <== NOT EXECUTED 108808: c3 ret <== NOT EXECUTED 00123f84 : fclose(group_fp); group_fp = fopen("/etc/group", "r"); } void endgrent(void) { 123f84: 55 push %ebp <== NOT EXECUTED 123f85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123f87: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (group_fp != NULL) 123f8a: a1 64 14 16 00 mov 0x161464,%eax <== NOT EXECUTED 123f8f: 85 c0 test %eax,%eax <== NOT EXECUTED 123f91: 74 0c je 123f9f <== NOT EXECUTED fclose(group_fp); 123f93: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123f96: 50 push %eax <== NOT EXECUTED 123f97: e8 04 da 00 00 call 1319a0 <== NOT EXECUTED 123f9c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 123f9f: c9 leave <== NOT EXECUTED 123fa0: c3 ret <== NOT EXECUTED 00123fa4 : fclose(passwd_fp); passwd_fp = fopen("/etc/passwd", "r"); } void endpwent(void) { 123fa4: 55 push %ebp <== NOT EXECUTED 123fa5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123fa7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (passwd_fp != NULL) 123faa: a1 64 13 16 00 mov 0x161364,%eax <== NOT EXECUTED 123faf: 85 c0 test %eax,%eax <== NOT EXECUTED 123fb1: 74 0c je 123fbf <== NOT EXECUTED fclose(passwd_fp); 123fb3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123fb6: 50 push %eax <== NOT EXECUTED 123fb7: e8 e4 d9 00 00 call 1319a0 <== NOT EXECUTED 123fbc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 123fbf: c9 leave <== NOT EXECUTED 123fc0: c3 ret <== NOT EXECUTED 0010880c : * 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) { 10880c: 55 push %ebp <== NOT EXECUTED 10880d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10880f: 57 push %edi <== NOT EXECUTED 108810: 56 push %esi <== NOT EXECUTED 108811: 53 push %ebx <== NOT EXECUTED 108812: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 108815: 89 c3 mov %eax,%ebx <== NOT EXECUTED 108817: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED if (tty->ccount == 0) 10881a: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED 10881d: 85 c0 test %eax,%eax <== NOT EXECUTED 10881f: 74 57 je 108878 <== NOT EXECUTED return; if (lineFlag) { 108821: 85 d2 test %edx,%edx <== NOT EXECUTED 108823: 0f 85 bb 00 00 00 jne 1088e4 <== NOT EXECUTED 108829: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10882c: 8b 4b 3c mov 0x3c(%ebx),%ecx <== NOT EXECUTED echo ('\n', tty); return; } } while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; 10882f: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED 108832: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 108835: 8d 78 ff lea -0x1(%eax),%edi <== NOT EXECUTED 108838: 89 7b 20 mov %edi,0x20(%ebx) <== NOT EXECUTED 10883b: 8a 04 3a mov (%edx,%edi,1),%al <== NOT EXECUTED if (tty->termios.c_lflag & ECHO) { 10883e: f6 c1 08 test $0x8,%cl <== NOT EXECUTED 108841: 74 25 je 108868 <== NOT EXECUTED if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { 108843: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 108846: 85 d2 test %edx,%edx <== NOT EXECUTED 108848: 74 36 je 108880 <== NOT EXECUTED echo (tty->termios.c_cc[VERASE], tty); } else if (c == '\t') { 10884a: 3c 09 cmp $0x9,%al <== NOT EXECUTED 10884c: 0f 84 d2 00 00 00 je 108924 <== NOT EXECUTED rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 108852: 0f b6 f0 movzbl %al,%esi <== NOT EXECUTED 108855: a1 34 d6 11 00 mov 0x11d634,%eax <== NOT EXECUTED 10885a: f6 04 30 20 testb $0x20,(%eax,%esi,1) <== NOT EXECUTED 10885e: 74 65 je 1088c5 <== NOT EXECUTED 108860: 80 e5 02 and $0x2,%ch <== NOT EXECUTED 108863: 75 33 jne 108898 <== NOT EXECUTED 108865: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (tty->column) tty->column--; } } } if (!lineFlag) 108868: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10886b: 85 c0 test %eax,%eax <== NOT EXECUTED 10886d: 74 09 je 108878 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) echo ('\n', tty); return; } } while (tty->ccount) { 10886f: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 108872: 85 c0 test %eax,%eax <== NOT EXECUTED 108874: 75 b6 jne 10882c <== NOT EXECUTED 108876: 66 90 xchg %ax,%ax <== NOT EXECUTED } } if (!lineFlag) break; } } 108878: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10887b: 5b pop %ebx <== NOT EXECUTED 10887c: 5e pop %esi <== NOT EXECUTED 10887d: 5f pop %edi <== NOT EXECUTED 10887e: c9 leave <== NOT EXECUTED 10887f: c3 ret <== 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)) { 108880: f6 c1 10 test $0x10,%cl <== NOT EXECUTED 108883: 75 c5 jne 10884a <== NOT EXECUTED echo (tty->termios.c_cc[VERASE], tty); 108885: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED 108889: 89 da mov %ebx,%edx <== NOT EXECUTED } } if (!lineFlag) break; } } 10888b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10888e: 5b pop %ebx <== NOT EXECUTED 10888f: 5e pop %esi <== NOT EXECUTED 108890: 5f pop %edi <== NOT EXECUTED 108891: c9 leave <== 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); 108892: e9 15 ff ff ff jmp 1087ac <== NOT EXECUTED 108897: 90 nop <== NOT EXECUTED tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { rtems_termios_puts ("\b \b", 3, tty); 108898: 52 push %edx <== NOT EXECUTED 108899: 53 push %ebx <== NOT EXECUTED 10889a: 6a 03 push $0x3 <== NOT EXECUTED 10889c: 68 e3 8f 11 00 push $0x118fe3 <== NOT EXECUTED 1088a1: e8 a6 fc ff ff call 10854c <== NOT EXECUTED if (tty->column) 1088a6: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 1088a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1088ac: 85 c0 test %eax,%eax <== NOT EXECUTED 1088ae: 74 04 je 1088b4 <== NOT EXECUTED tty->column--; 1088b0: 48 dec %eax <== NOT EXECUTED 1088b1: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED } if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) { 1088b4: a1 34 d6 11 00 mov 0x11d634,%eax <== NOT EXECUTED 1088b9: f6 04 30 20 testb $0x20,(%eax,%esi,1) <== NOT EXECUTED 1088bd: 74 06 je 1088c5 <== NOT EXECUTED 1088bf: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED 1088c3: 74 a3 je 108868 <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); 1088c5: 50 push %eax <== NOT EXECUTED 1088c6: 53 push %ebx <== NOT EXECUTED 1088c7: 6a 03 push $0x3 <== NOT EXECUTED 1088c9: 68 e3 8f 11 00 push $0x118fe3 <== NOT EXECUTED 1088ce: e8 79 fc ff ff call 10854c <== NOT EXECUTED if (tty->column) 1088d3: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 1088d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1088d9: 85 c0 test %eax,%eax <== NOT EXECUTED 1088db: 74 8b je 108868 <== NOT EXECUTED tty->column--; 1088dd: 48 dec %eax <== NOT EXECUTED 1088de: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 1088e1: eb 85 jmp 108868 <== NOT EXECUTED 1088e3: 90 nop <== NOT EXECUTED erase (struct rtems_termios_tty *tty, int lineFlag) { if (tty->ccount == 0) return; if (lineFlag) { if (!(tty->termios.c_lflag & ECHO)) { 1088e4: 8b 4b 3c mov 0x3c(%ebx),%ecx <== NOT EXECUTED 1088e7: f6 c1 08 test $0x8,%cl <== NOT EXECUTED 1088ea: 0f 84 b4 00 00 00 je 1089a4 <== NOT EXECUTED tty->ccount = 0; return; } if (!(tty->termios.c_lflag & ECHOE)) { 1088f0: f6 c1 10 test $0x10,%cl <== NOT EXECUTED 1088f3: 0f 85 36 ff ff ff jne 10882f <== NOT EXECUTED tty->ccount = 0; 1088f9: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED echo (tty->termios.c_cc[VKILL], tty); 108900: 0f b6 43 44 movzbl 0x44(%ebx),%eax <== NOT EXECUTED 108904: 89 da mov %ebx,%edx <== NOT EXECUTED 108906: e8 a1 fe ff ff call 1087ac <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) 10890b: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED 10890f: 0f 84 63 ff ff ff je 108878 <== NOT EXECUTED echo ('\n', tty); 108915: 89 da mov %ebx,%edx <== NOT EXECUTED 108917: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 10891c: e9 6a ff ff ff jmp 10888b <== NOT EXECUTED 108921: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (tty->termios.c_lflag & ECHO) { if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { echo (tty->termios.c_cc[VERASE], tty); } else if (c == '\t') { int col = tty->read_start_column; 108924: 8b 73 2c mov 0x2c(%ebx),%esi <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 108927: 85 ff test %edi,%edi <== NOT EXECUTED 108929: 74 3f je 10896a <== NOT EXECUTED c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { 10892b: a1 34 d6 11 00 mov 0x11d634,%eax <== NOT EXECUTED 108930: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 108933: 31 d2 xor %edx,%edx <== NOT EXECUTED if (tty->termios.c_lflag & ECHOCTL) 108935: 81 e1 00 02 00 00 and $0x200,%ecx <== NOT EXECUTED 10893b: 89 4d e4 mov %ecx,-0x1c(%ebp) <== NOT EXECUTED 10893e: eb 0e jmp 10894e <== NOT EXECUTED 108940: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 108943: 85 c0 test %eax,%eax <== NOT EXECUTED 108945: 74 03 je 10894a <== NOT EXECUTED col += 2; 108947: 83 c6 02 add $0x2,%esi <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 10894a: 39 d7 cmp %edx,%edi <== NOT EXECUTED 10894c: 74 1c je 10896a <== NOT EXECUTED c = tty->cbuf[i++]; 10894e: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 108951: 8a 04 11 mov (%ecx,%edx,1),%al <== NOT EXECUTED 108954: 42 inc %edx <== NOT EXECUTED if (c == '\t') { 108955: 3c 09 cmp $0x9,%al <== NOT EXECUTED 108957: 74 3f je 108998 <== NOT EXECUTED col = (col | 7) + 1; } else if (iscntrl (c)) { 108959: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10895c: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10895f: f6 04 01 20 testb $0x20,(%ecx,%eax,1) <== NOT EXECUTED 108963: 75 db jne 108940 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOCTL) col += 2; } else { col++; 108965: 46 inc %esi <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 108966: 39 d7 cmp %edx,%edi <== NOT EXECUTED 108968: 75 e4 jne 10894e <== NOT EXECUTED } /* * Back up over the tab */ while (tty->column > col) { 10896a: 39 73 28 cmp %esi,0x28(%ebx) <== NOT EXECUTED 10896d: 0f 8e f5 fe ff ff jle 108868 <== NOT EXECUTED 108973: 90 nop <== NOT EXECUTED rtems_termios_puts ("\b", 1, tty); 108974: 51 push %ecx <== NOT EXECUTED 108975: 53 push %ebx <== NOT EXECUTED 108976: 6a 01 push $0x1 <== NOT EXECUTED 108978: 68 e5 8f 11 00 push $0x118fe5 <== NOT EXECUTED 10897d: e8 ca fb ff ff call 10854c <== NOT EXECUTED tty->column--; 108982: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 108985: 48 dec %eax <== NOT EXECUTED 108986: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED } /* * Back up over the tab */ while (tty->column > col) { 108989: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10898c: 39 f0 cmp %esi,%eax <== NOT EXECUTED 10898e: 7f e4 jg 108974 <== NOT EXECUTED 108990: e9 d3 fe ff ff jmp 108868 <== NOT EXECUTED 108995: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * Find the character before the tab */ while (i != tty->ccount) { c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; 108998: 89 f0 mov %esi,%eax <== NOT EXECUTED 10899a: 83 c8 07 or $0x7,%eax <== NOT EXECUTED 10899d: 8d 70 01 lea 0x1(%eax),%esi <== NOT EXECUTED 1089a0: eb a8 jmp 10894a <== NOT EXECUTED 1089a2: 66 90 xchg %ax,%ax <== NOT EXECUTED { if (tty->ccount == 0) return; if (lineFlag) { if (!(tty->termios.c_lflag & ECHO)) { tty->ccount = 0; 1089a4: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED } } if (!lineFlag) break; } } 1089ab: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1089ae: 5b pop %ebx <== NOT EXECUTED 1089af: 5e pop %esi <== NOT EXECUTED 1089b0: 5f pop %edi <== NOT EXECUTED 1089b1: c9 leave <== NOT EXECUTED 1089b2: c3 ret <== NOT EXECUTED 0010a2f8 : const char *path, const char *arg, ... ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 10a2f8: 55 push %ebp <== NOT EXECUTED 10a2f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a2fb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a2fe: e8 7d 77 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a303: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a309: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a30e: c9 leave <== NOT EXECUTED 10a30f: c3 ret <== NOT EXECUTED 0010a2e0 : const char *path, char const *arg, ... ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 10a2e0: 55 push %ebp <== NOT EXECUTED 10a2e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a2e3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a2e6: e8 95 77 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a2eb: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a2f1: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a2f6: c9 leave <== NOT EXECUTED 10a2f7: c3 ret <== NOT EXECUTED 0010a310 : const char *file, const char *arg, ... ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 10a310: 55 push %ebp <== NOT EXECUTED 10a311: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a313: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a316: e8 65 77 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a31b: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a321: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a326: c9 leave <== NOT EXECUTED 10a327: c3 ret <== NOT EXECUTED 0010a340 : int execv( const char *file, char *const argv[] ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 10a340: 55 push %ebp <== NOT EXECUTED 10a341: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a343: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a346: e8 35 77 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a34b: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a351: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a356: c9 leave <== NOT EXECUTED 10a357: c3 ret <== NOT EXECUTED 0010a328 : const char *path, char *const argv[], char *const envp[] ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 10a328: 55 push %ebp <== NOT EXECUTED 10a329: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a32b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a32e: e8 4d 77 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a333: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a339: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a33e: c9 leave <== NOT EXECUTED 10a33f: c3 ret <== NOT EXECUTED 0010a358 : int execvp( const char *path, char *const argv[] ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 10a358: 55 push %ebp <== NOT EXECUTED 10a359: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a35b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a35e: e8 1d 77 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a363: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a369: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a36e: c9 leave <== NOT EXECUTED 10a36f: c3 ret <== NOT EXECUTED 0012f818 : #include int fchdir( int fd ) { 12f818: 55 push %ebp <== NOT EXECUTED 12f819: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f81b: 57 push %edi <== NOT EXECUTED 12f81c: 56 push %esi <== NOT EXECUTED 12f81d: 53 push %ebx <== NOT EXECUTED 12f81e: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 12f821: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED rtems_libio_t *iop; rtems_filesystem_location_info_t loc, saved; rtems_libio_check_fd( fd ); 12f824: 3b 15 40 90 14 00 cmp 0x149040,%edx <== NOT EXECUTED 12f82a: 0f 83 cc 00 00 00 jae 12f8fc <== NOT EXECUTED iop = rtems_libio_iop( fd ); 12f830: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 12f833: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 12f836: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 12f839: 03 05 58 1d 16 00 add 0x161d58,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 12f83f: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 12f842: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 12f845: 0f 84 b1 00 00 00 je 12f8fc <== NOT EXECUTED /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 12f84b: 83 e2 02 and $0x2,%edx <== NOT EXECUTED 12f84e: 0f 84 d8 00 00 00 je 12f92c <== NOT EXECUTED /* * Verify you can change directory into this node. */ if ( !iop->pathinfo.ops ) { 12f854: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED 12f857: 85 d2 test %edx,%edx <== NOT EXECUTED 12f859: 0f 84 df 00 00 00 je 12f93e <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( !iop->pathinfo.ops->node_type_h ) { 12f85f: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 12f862: 85 d2 test %edx,%edx <== NOT EXECUTED 12f864: 0f 84 d4 00 00 00 je 12f93e <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) != 12f86a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12f86d: 8d 58 10 lea 0x10(%eax),%ebx <== NOT EXECUTED 12f870: 53 push %ebx <== NOT EXECUTED 12f871: ff d2 call *%edx <== NOT EXECUTED 12f873: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12f876: 48 dec %eax <== NOT EXECUTED 12f877: 75 6f jne 12f8e8 <== NOT EXECUTED * but note the race condition. Threads who * share their rtems_filesystem_current better * be synchronized! */ saved = rtems_filesystem_current; 12f879: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED 12f87e: 8d 55 d4 lea -0x2c(%ebp),%edx <== NOT EXECUTED 12f881: 89 55 d0 mov %edx,-0x30(%ebp) <== NOT EXECUTED 12f884: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 12f887: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12f88c: 89 d7 mov %edx,%edi <== NOT EXECUTED 12f88e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED rtems_filesystem_current = iop->pathinfo; 12f890: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 12f893: b1 04 mov $0x4,%cl <== NOT EXECUTED 12f895: 89 de mov %ebx,%esi <== NOT EXECUTED 12f897: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* clone the current node */ if (rtems_filesystem_evaluate_path(".", 0, &loc, 0)) { 12f899: 6a 00 push $0x0 <== NOT EXECUTED 12f89b: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 12f89e: 56 push %esi <== NOT EXECUTED 12f89f: 6a 00 push $0x0 <== NOT EXECUTED 12f8a1: 68 b0 27 14 00 push $0x1427b0 <== NOT EXECUTED 12f8a6: e8 81 b9 fd ff call 10b22c <== NOT EXECUTED 12f8ab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12f8ae: 85 c0 test %eax,%eax <== NOT EXECUTED 12f8b0: 75 5e jne 12f910 <== NOT EXECUTED /* cloning failed; restore original and bail out */ rtems_filesystem_current = saved; return -1; } /* release the old one */ rtems_filesystem_freenode( &saved ); 12f8b2: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 12f8b5: 85 c0 test %eax,%eax <== NOT EXECUTED 12f8b7: 74 13 je 12f8cc <== NOT EXECUTED 12f8b9: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12f8bc: 85 c0 test %eax,%eax <== NOT EXECUTED 12f8be: 74 0c je 12f8cc <== NOT EXECUTED 12f8c0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12f8c3: 8d 55 d4 lea -0x2c(%ebp),%edx <== NOT EXECUTED 12f8c6: 52 push %edx <== NOT EXECUTED 12f8c7: ff d0 call *%eax <== NOT EXECUTED 12f8c9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_current = loc; 12f8cc: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED 12f8d1: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 12f8d4: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12f8d9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 12f8db: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 12f8dd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12f8e0: 5b pop %ebx <== NOT EXECUTED 12f8e1: 5e pop %esi <== NOT EXECUTED 12f8e2: 5f pop %edi <== NOT EXECUTED 12f8e3: c9 leave <== NOT EXECUTED 12f8e4: c3 ret <== NOT EXECUTED 12f8e5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) != RTEMS_FILESYSTEM_DIRECTORY ) { rtems_set_errno_and_return_minus_one( ENOTDIR ); 12f8e8: e8 67 1f 00 00 call 131854 <__errno> <== NOT EXECUTED 12f8ed: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 12f8f3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12f8f8: eb e3 jmp 12f8dd <== NOT EXECUTED 12f8fa: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_libio_t *iop; rtems_filesystem_location_info_t loc, saved; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 12f8fc: e8 53 1f 00 00 call 131854 <__errno> <== NOT EXECUTED 12f901: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 12f907: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12f90c: eb cf jmp 12f8dd <== NOT EXECUTED 12f90e: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_filesystem_current = iop->pathinfo; /* clone the current node */ if (rtems_filesystem_evaluate_path(".", 0, &loc, 0)) { /* cloning failed; restore original and bail out */ rtems_filesystem_current = saved; 12f910: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED 12f915: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 12f918: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12f91d: 8b 75 d0 mov -0x30(%ebp),%esi <== NOT EXECUTED 12f920: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 12f922: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12f927: eb b4 jmp 12f8dd <== NOT EXECUTED 12f929: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 12f92c: e8 23 1f 00 00 call 131854 <__errno> <== NOT EXECUTED 12f931: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 12f937: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12f93c: eb 9f jmp 12f8dd <== NOT EXECUTED if ( !iop->pathinfo.ops ) { rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( !iop->pathinfo.ops->node_type_h ) { rtems_set_errno_and_return_minus_one( ENOTSUP ); 12f93e: e8 11 1f 00 00 call 131854 <__errno> <== NOT EXECUTED 12f943: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12f949: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12f94e: eb 8d jmp 12f8dd <== NOT EXECUTED 001237e0 : int fchmod( int fd, mode_t mode ) { 1237e0: 55 push %ebp <== NOT EXECUTED 1237e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1237e3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1237e6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1237e9: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 1237ec: 3b 15 40 90 14 00 cmp 0x149040,%edx <== NOT EXECUTED 1237f2: 73 3c jae 123830 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 1237f4: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 1237f7: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 1237fa: 8d 14 85 00 00 00 00 lea 0x0(,%eax,4),%edx <== NOT EXECUTED 123801: 03 15 58 1d 16 00 add 0x161d58,%edx <== NOT EXECUTED rtems_libio_check_is_open(iop); 123807: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 12380a: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 12380d: 74 21 je 123830 <== NOT EXECUTED /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 12380f: a8 04 test $0x4,%al <== NOT EXECUTED 123811: 74 31 je 123844 <== NOT EXECUTED if ( !iop->handlers->fchmod_h ) 123813: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 123816: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 123819: 85 c0 test %eax,%eax <== NOT EXECUTED 12381b: 74 34 je 123851 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); 12381d: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 123820: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED 123823: 83 c2 10 add $0x10,%edx <== NOT EXECUTED 123826: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED 123829: 8b 48 1c mov 0x1c(%eax),%ecx <== NOT EXECUTED } 12382c: c9 leave <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); if ( !iop->handlers->fchmod_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); 12382d: ff e1 jmp *%ecx <== NOT EXECUTED 12382f: 90 nop <== NOT EXECUTED { rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 123830: e8 1f e0 00 00 call 131854 <__errno> <== NOT EXECUTED 123835: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED if ( !iop->handlers->fchmod_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); } 12383b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 123840: c9 leave <== NOT EXECUTED 123841: c3 ret <== NOT EXECUTED 123842: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 123844: e8 0b e0 00 00 call 131854 <__errno> <== NOT EXECUTED 123849: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 12384f: eb ea jmp 12383b <== NOT EXECUTED if ( !iop->handlers->fchmod_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 123851: e8 fe df 00 00 call 131854 <__errno> <== NOT EXECUTED 123856: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12385c: eb dd jmp 12383b <== NOT EXECUTED 00123860 : int fchown( int fd, uid_t owner, gid_t group ) { 123860: 55 push %ebp <== NOT EXECUTED 123861: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123863: 56 push %esi <== NOT EXECUTED 123864: 53 push %ebx <== NOT EXECUTED 123865: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 123868: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 12386b: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 12386e: 3b 15 40 90 14 00 cmp 0x149040,%edx <== NOT EXECUTED 123874: 73 42 jae 1238b8 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 123876: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 123879: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 12387c: 8d 14 85 00 00 00 00 lea 0x0(,%eax,4),%edx <== NOT EXECUTED 123883: 03 15 58 1d 16 00 add 0x161d58,%edx <== NOT EXECUTED rtems_libio_check_is_open(iop); 123889: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 12388c: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 12388f: 74 27 je 1238b8 <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 123891: a8 04 test $0x4,%al <== NOT EXECUTED 123893: 74 37 je 1238cc <== NOT EXECUTED if ( !iop->pathinfo.ops->chown_h ) 123895: 8b 42 18 mov 0x18(%edx),%eax <== NOT EXECUTED 123898: 8b 48 18 mov 0x18(%eax),%ecx <== NOT EXECUTED 12389b: 85 c9 test %ecx,%ecx <== NOT EXECUTED 12389d: 74 3a je 1238d9 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group ); 12389f: 0f b7 c3 movzwl %bx,%eax <== NOT EXECUTED 1238a2: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 1238a5: 0f b7 c6 movzwl %si,%eax <== NOT EXECUTED 1238a8: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1238ab: 8d 42 10 lea 0x10(%edx),%eax <== NOT EXECUTED 1238ae: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 1238b1: 5b pop %ebx <== NOT EXECUTED 1238b2: 5e pop %esi <== NOT EXECUTED 1238b3: c9 leave <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); if ( !iop->pathinfo.ops->chown_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group ); 1238b4: ff e1 jmp *%ecx <== NOT EXECUTED 1238b6: 66 90 xchg %ax,%ax <== NOT EXECUTED { rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 1238b8: e8 97 df 00 00 call 131854 <__errno> <== NOT EXECUTED 1238bd: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED if ( !iop->pathinfo.ops->chown_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group ); } 1238c3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1238c8: 5b pop %ebx <== NOT EXECUTED 1238c9: 5e pop %esi <== NOT EXECUTED 1238ca: c9 leave <== NOT EXECUTED 1238cb: c3 ret <== NOT EXECUTED rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 1238cc: e8 83 df 00 00 call 131854 <__errno> <== NOT EXECUTED 1238d1: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1238d7: eb ea jmp 1238c3 <== NOT EXECUTED if ( !iop->pathinfo.ops->chown_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 1238d9: e8 76 df 00 00 call 131854 <__errno> <== NOT EXECUTED 1238de: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1238e4: eb dd jmp 1238c3 <== NOT EXECUTED 0012f950 : int fcntl( int fd, int cmd, ... ) { 12f950: 55 push %ebp <== NOT EXECUTED 12f951: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f953: 57 push %edi <== NOT EXECUTED 12f954: 56 push %esi <== NOT EXECUTED 12f955: 53 push %ebx <== NOT EXECUTED 12f956: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12f959: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 12f95c: 8d 5d 10 lea 0x10(%ebp),%ebx <== NOT EXECUTED int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 12f95f: 8b 0d 40 90 14 00 mov 0x149040,%ecx <== NOT EXECUTED 12f965: 39 ca cmp %ecx,%edx <== NOT EXECUTED 12f967: 0f 83 7f 01 00 00 jae 12faec <== NOT EXECUTED iop = rtems_libio_iop( fd ); 12f96d: 8b 35 58 1d 16 00 mov 0x161d58,%esi <== NOT EXECUTED 12f973: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 12f976: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 12f979: 8d 04 86 lea (%esi,%eax,4),%eax <== NOT EXECUTED 12f97c: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED rtems_libio_check_is_open(iop); 12f97f: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 12f982: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 12f985: 0f 84 61 01 00 00 je 12faec <== NOT EXECUTED /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 12f98b: 83 7d 0c 09 cmpl $0x9,0xc(%ebp) <== NOT EXECUTED 12f98f: 76 13 jbe 12f9a4 <== NOT EXECUTED errno = ENOTSUP; ret = -1; break; default: errno = EINVAL; 12f991: e8 be 1e 00 00 call 131854 <__errno> <== NOT EXECUTED 12f996: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 12f99c: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 12f9a1: eb 1d jmp 12f9c0 <== NOT EXECUTED 12f9a3: 90 nop <== NOT EXECUTED /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 12f9a4: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 12f9a7: ff 24 85 44 67 14 00 jmp *0x146744(,%eax,4) <== NOT EXECUTED 12f9ae: 66 90 xchg %ax,%ax <== NOT EXECUTED errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 12f9b0: e8 9f 1e 00 00 call 131854 <__errno> <== NOT EXECUTED 12f9b5: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12f9bb: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; } 12f9c0: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12f9c2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12f9c5: 5b pop %ebx <== NOT EXECUTED 12f9c6: 5e pop %esi <== NOT EXECUTED 12f9c7: 5f pop %edi <== NOT EXECUTED 12f9c8: c9 leave <== NOT EXECUTED 12f9c9: c3 ret <== NOT EXECUTED 12f9ca: 66 90 xchg %ax,%ax <== NOT EXECUTED 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 ) ); 12f9cc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12f9cf: ff 33 pushl (%ebx) <== NOT EXECUTED 12f9d1: e8 6a bd fd ff call 10b740 <== NOT EXECUTED /* * XXX If we are turning on append, should we seek to the end? */ iop->flags = (iop->flags & ~mask) | (flags & mask); 12f9d6: 25 01 02 00 00 and $0x201,%eax <== NOT EXECUTED 12f9db: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 12f9de: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED 12f9e1: 81 e2 fe fd ff ff and $0xfffffdfe,%edx <== NOT EXECUTED 12f9e7: 09 c2 or %eax,%edx <== NOT EXECUTED 12f9e9: 89 51 0c mov %edx,0xc(%ecx) <== NOT EXECUTED 12f9ec: 31 db xor %ebx,%ebx <== NOT EXECUTED 12f9ee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * 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) { 12f9f1: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 12f9f4: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 12f9f7: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED 12f9fa: 85 c0 test %eax,%eax <== NOT EXECUTED 12f9fc: 74 c2 je 12f9c0 <== NOT EXECUTED int err = (*iop->handlers->fcntl_h)( cmd, iop ); 12f9fe: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12fa01: 52 push %edx <== NOT EXECUTED 12fa02: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 12fa05: ff d0 call *%eax <== NOT EXECUTED 12fa07: 89 c6 mov %eax,%esi <== NOT EXECUTED if (err) { 12fa09: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12fa0c: 85 c0 test %eax,%eax <== NOT EXECUTED 12fa0e: 74 b0 je 12f9c0 <== NOT EXECUTED errno = err; 12fa10: e8 3f 1e 00 00 call 131854 <__errno> <== NOT EXECUTED 12fa15: 89 30 mov %esi,(%eax) <== NOT EXECUTED 12fa17: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; } 12fa1c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12fa1e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12fa21: 5b pop %ebx <== NOT EXECUTED 12fa22: 5e pop %esi <== NOT EXECUTED 12fa23: 5f pop %edi <== NOT EXECUTED 12fa24: c9 leave <== NOT EXECUTED 12fa25: c3 ret <== NOT EXECUTED 12fa26: 66 90 xchg %ax,%ax <== 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 ); 12fa28: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12fa2b: 52 push %edx <== NOT EXECUTED 12fa2c: e8 f3 ba fd ff call 10b524 <== NOT EXECUTED 12fa31: 89 c3 mov %eax,%ebx <== NOT EXECUTED 12fa33: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * If we got this far successfully, then we give the optional * filesystem specific handler a chance to process this. */ if (ret >= 0) { 12fa36: 85 db test %ebx,%ebx <== NOT EXECUTED 12fa38: 79 b7 jns 12f9f1 <== NOT EXECUTED 12fa3a: eb 84 jmp 12f9c0 <== 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 ) ) 12fa3c: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 12fa3e: 85 c0 test %eax,%eax <== NOT EXECUTED 12fa40: 0f 84 86 00 00 00 je 12facc <== NOT EXECUTED iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; 12fa46: 80 ce 08 or $0x8,%dh <== NOT EXECUTED 12fa49: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 12fa4c: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED 12fa4f: 31 db xor %ebx,%ebx <== NOT EXECUTED 12fa51: eb 9e jmp 12f9f1 <== NOT EXECUTED 12fa53: 90 nop <== NOT EXECUTED 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); 12fa54: 89 d3 mov %edx,%ebx <== NOT EXECUTED 12fa56: c1 eb 0b shr $0xb,%ebx <== NOT EXECUTED 12fa59: 83 e3 01 and $0x1,%ebx <== NOT EXECUTED 12fa5c: eb 93 jmp 12f9f1 <== NOT EXECUTED 12fa5e: 66 90 xchg %ax,%ax <== NOT EXECUTED * This switch should contain all the cases from POSIX. */ switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); 12fa60: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED if ( fd2 ) 12fa62: 85 db test %ebx,%ebx <== NOT EXECUTED 12fa64: 0f 84 9a 00 00 00 je 12fb04 <== NOT EXECUTED diop = rtems_libio_iop( fd2 ); 12fa6a: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 12fa6c: 77 6e ja 12fadc <== NOT EXECUTED 12fa6e: 31 db xor %ebx,%ebx <== NOT EXECUTED 12fa70: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED ret = -1; break; } } diop->handlers = iop->handlers; 12fa77: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 12fa7a: 8b 41 30 mov 0x30(%ecx),%eax <== NOT EXECUTED 12fa7d: 89 43 30 mov %eax,0x30(%ebx) <== NOT EXECUTED diop->file_info = iop->file_info; 12fa80: 8b 41 2c mov 0x2c(%ecx),%eax <== NOT EXECUTED 12fa83: 89 43 2c mov %eax,0x2c(%ebx) <== NOT EXECUTED diop->flags = iop->flags; 12fa86: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED diop->pathinfo = iop->pathinfo; 12fa89: 8d 7b 10 lea 0x10(%ebx),%edi <== NOT EXECUTED 12fa8c: 89 ce mov %ecx,%esi <== NOT EXECUTED 12fa8e: 83 c6 10 add $0x10,%esi <== NOT EXECUTED 12fa91: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12fa96: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED ret = (int) (diop - rtems_libio_iops); 12fa98: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 12fa9b: 2b 0d 58 1d 16 00 sub 0x161d58,%ecx <== NOT EXECUTED 12faa1: c1 f9 02 sar $0x2,%ecx <== NOT EXECUTED 12faa4: 8d 14 89 lea (%ecx,%ecx,4),%edx <== NOT EXECUTED 12faa7: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 12faaa: 89 d0 mov %edx,%eax <== NOT EXECUTED 12faac: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 12faaf: 29 d0 sub %edx,%eax <== NOT EXECUTED 12fab1: 89 c2 mov %eax,%edx <== NOT EXECUTED 12fab3: c1 e2 0c shl $0xc,%edx <== NOT EXECUTED 12fab6: 01 d0 add %edx,%eax <== NOT EXECUTED 12fab8: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED 12fabb: 8d 04 41 lea (%ecx,%eax,2),%eax <== NOT EXECUTED 12fabe: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 12fac1: 01 c8 add %ecx,%eax <== NOT EXECUTED 12fac3: 8d 1c 81 lea (%ecx,%eax,4),%ebx <== NOT EXECUTED 12fac6: e9 6b ff ff ff jmp 12fa36 <== NOT EXECUTED 12facb: 90 nop <== NOT EXECUTED */ if ( va_arg( ap, int ) ) iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; 12facc: 80 e6 f7 and $0xf7,%dh <== NOT EXECUTED 12facf: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 12fad2: 89 51 0c mov %edx,0xc(%ecx) <== NOT EXECUTED 12fad5: 31 db xor %ebx,%ebx <== NOT EXECUTED 12fad7: e9 15 ff ff ff jmp 12f9f1 <== NOT EXECUTED switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); if ( fd2 ) diop = rtems_libio_iop( fd2 ); 12fadc: 8d 04 5b lea (%ebx,%ebx,2),%eax <== NOT EXECUTED 12fadf: 8d 04 83 lea (%ebx,%eax,4),%eax <== NOT EXECUTED 12fae2: 8d 1c 86 lea (%esi,%eax,4),%ebx <== NOT EXECUTED 12fae5: 89 5d f0 mov %ebx,-0x10(%ebp) <== NOT EXECUTED 12fae8: eb 8d jmp 12fa77 <== NOT EXECUTED 12faea: 66 90 xchg %ax,%ax <== NOT EXECUTED int mask; int ret = 0; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 12faec: e8 63 1d 00 00 call 131854 <__errno> <== NOT EXECUTED 12faf1: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 12faf7: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 12fafc: e9 bf fe ff ff jmp 12f9c0 <== NOT EXECUTED 12fb01: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED fd2 = va_arg( ap, int ); if ( fd2 ) diop = rtems_libio_iop( fd2 ); else { /* allocate a file control block */ diop = rtems_libio_allocate(); 12fb04: e8 7b bb fd ff call 10b684 <== NOT EXECUTED 12fb09: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( diop == 0 ) { 12fb0b: 85 c0 test %eax,%eax <== NOT EXECUTED 12fb0d: 0f 84 04 ff ff ff je 12fa17 <== NOT EXECUTED 12fb13: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 12fb16: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 12fb19: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED 12fb1c: e9 56 ff ff ff jmp 12fa77 <== NOT EXECUTED 001080c8 : #include int fdatasync( int fd ) { 1080c8: 55 push %ebp <== NOT EXECUTED 1080c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1080cb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1080ce: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 1080d1: 3b 15 40 f5 11 00 cmp 0x11f540,%edx <== NOT EXECUTED 1080d7: 73 2f jae 108108 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 1080d9: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 1080dc: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 1080df: 8d 14 85 00 00 00 00 lea 0x0(,%eax,4),%edx <== NOT EXECUTED 1080e6: 03 15 30 3a 12 00 add 0x123a30,%edx <== NOT EXECUTED rtems_libio_check_is_open(iop); 1080ec: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 1080ef: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 1080f2: 74 14 je 108108 <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 1080f4: a8 04 test $0x4,%al <== NOT EXECUTED 1080f6: 74 24 je 10811c <== NOT EXECUTED /* * Now process the fdatasync(). */ if ( !iop->handlers->fdatasync_h ) 1080f8: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 1080fb: 8b 48 2c mov 0x2c(%eax),%ecx <== NOT EXECUTED 1080fe: 85 c9 test %ecx,%ecx <== NOT EXECUTED 108100: 74 27 je 108129 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->fdatasync_h)( iop ); 108102: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 108105: c9 leave <== NOT EXECUTED */ if ( !iop->handlers->fdatasync_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->fdatasync_h)( iop ); 108106: ff e1 jmp *%ecx <== NOT EXECUTED { rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 108108: e8 2b b0 00 00 call 113138 <__errno> <== NOT EXECUTED 10810d: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED if ( !iop->handlers->fdatasync_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->fdatasync_h)( iop ); } 108113: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 108118: c9 leave <== NOT EXECUTED 108119: c3 ret <== NOT EXECUTED 10811a: 66 90 xchg %ax,%ax <== 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 ); 10811c: e8 17 b0 00 00 call 113138 <__errno> <== NOT EXECUTED 108121: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 108127: eb ea jmp 108113 <== NOT EXECUTED /* * Now process the fdatasync(). */ if ( !iop->handlers->fdatasync_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 108129: e8 0a b0 00 00 call 113138 <__errno> <== NOT EXECUTED 10812e: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 108134: eb dd jmp 108113 <== NOT EXECUTED 00125628 : bool file_systems_below_this_mountpoint( const char *path, rtems_filesystem_location_info_t *fs_root_loc, rtems_filesystem_mount_table_entry_t *fs_to_unmount ) { 125628: 55 push %ebp <== NOT EXECUTED 125629: 89 e5 mov %esp,%ebp <== NOT EXECUTED /* * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; 12562b: a1 0c 1e 16 00 mov 0x161e0c,%eax <== NOT EXECUTED !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); 125630: 3d 10 1e 16 00 cmp $0x161e10,%eax <== NOT EXECUTED 125635: 74 1b je 125652 <== 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 ) { 125637: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 12563a: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED 12563d: 39 50 14 cmp %edx,0x14(%eax) <== NOT EXECUTED 125640: 75 07 jne 125649 <== NOT EXECUTED 125642: eb 14 jmp 125658 <== NOT EXECUTED 125644: 39 50 14 cmp %edx,0x14(%eax) <== NOT EXECUTED 125647: 74 0f je 125658 <== NOT EXECUTED * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { 125649: 8b 00 mov (%eax),%eax <== NOT EXECUTED * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); 12564b: 3d 10 1e 16 00 cmp $0x161e10,%eax <== NOT EXECUTED 125650: 75 f2 jne 125644 <== NOT EXECUTED 125652: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; } } return false; } 125654: c9 leave <== NOT EXECUTED 125655: c3 ret <== NOT EXECUTED 125656: 66 90 xchg %ax,%ax <== NOT EXECUTED * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); 125658: b0 01 mov $0x1,%al <== NOT EXECUTED return true; } } return false; } 12565a: c9 leave <== NOT EXECUTED 12565b: c3 ret <== NOT EXECUTED 0010a370 : #include #include int fork( void ) { rtems_set_errno_and_return_minus_one( ENOSYS ); 10a370: 55 push %ebp <== NOT EXECUTED 10a371: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a373: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a376: e8 05 77 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a37b: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a381: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a386: c9 leave <== NOT EXECUTED 10a387: c3 ret <== NOT EXECUTED 00108138 : long fpathconf( int fd, int name ) { 108138: 55 push %ebp <== NOT EXECUTED 108139: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10813b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10813e: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED long return_value; rtems_libio_t *iop; rtems_filesystem_limits_and_options_t *the_limits; rtems_libio_check_fd(fd); 108141: 3b 15 40 f5 11 00 cmp 0x11f540,%edx <== NOT EXECUTED 108147: 0f 83 a7 00 00 00 jae 1081f4 <== NOT EXECUTED iop = rtems_libio_iop(fd); 10814d: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 108150: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 108153: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 108156: 03 05 30 3a 12 00 add 0x123a30,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 10815c: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 10815f: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 108162: 0f 84 8c 00 00 00 je 1081f4 <== NOT EXECUTED rtems_libio_check_permissions(iop, LIBIO_FLAGS_READ); 108168: 83 e2 02 and $0x2,%edx <== NOT EXECUTED 10816b: 74 09 je 108176 <== NOT EXECUTED /* * Now process the information request. */ the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; 10816d: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED switch ( name ) { 108170: 83 7d 0c 0b cmpl $0xb,0xc(%ebp) <== NOT EXECUTED 108174: 76 12 jbe 108188 <== NOT EXECUTED break; case _PC_SYNC_IO: return_value = the_limits->posix_sync_io; break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 108176: e8 bd af 00 00 call 113138 <__errno> <== NOT EXECUTED 10817b: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 108181: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED break; } return return_value; } 108186: c9 leave <== NOT EXECUTED 108187: c3 ret <== NOT EXECUTED * Now process the information request. */ the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; switch ( name ) { 108188: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10818b: ff 24 95 ac cf 11 00 jmp *0x11cfac(,%edx,4) <== NOT EXECUTED 108192: 66 90 xchg %ax,%ax <== NOT EXECUTED break; case _PC_PRIO_IO: return_value = the_limits->posix_prio_io; break; case _PC_SYNC_IO: return_value = the_limits->posix_sync_io; 108194: 8b 40 58 mov 0x58(%eax),%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108197: c9 leave <== NOT EXECUTED 108198: c3 ret <== NOT EXECUTED 108199: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_ASYNC_IO: return_value = the_limits->posix_async_io; break; case _PC_PRIO_IO: return_value = the_limits->posix_prio_io; 10819c: 8b 40 54 mov 0x54(%eax),%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 10819f: c9 leave <== NOT EXECUTED 1081a0: c3 ret <== NOT EXECUTED 1081a1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_VDISABLE: return_value = the_limits->posix_vdisable; break; case _PC_ASYNC_IO: return_value = the_limits->posix_async_io; 1081a4: 8b 40 48 mov 0x48(%eax),%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 1081a7: c9 leave <== NOT EXECUTED 1081a8: c3 ret <== NOT EXECUTED 1081a9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_NO_TRUNC: return_value = the_limits->posix_no_trunc; break; case _PC_VDISABLE: return_value = the_limits->posix_vdisable; 1081ac: 8b 40 5c mov 0x5c(%eax),%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 1081af: c9 leave <== NOT EXECUTED 1081b0: c3 ret <== NOT EXECUTED 1081b1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_CHOWN_RESTRICTED: return_value = the_limits->posix_chown_restrictions; break; case _PC_NO_TRUNC: return_value = the_limits->posix_no_trunc; 1081b4: 8b 40 50 mov 0x50(%eax),%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 1081b7: c9 leave <== NOT EXECUTED 1081b8: c3 ret <== NOT EXECUTED 1081b9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_PIPE_BUF: return_value = the_limits->pipe_buf; break; case _PC_CHOWN_RESTRICTED: return_value = the_limits->posix_chown_restrictions; 1081bc: 8b 40 4c mov 0x4c(%eax),%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 1081bf: c9 leave <== NOT EXECUTED 1081c0: c3 ret <== NOT EXECUTED 1081c1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_PATH_MAX: return_value = the_limits->path_max; break; case _PC_PIPE_BUF: return_value = the_limits->pipe_buf; 1081c4: 8b 40 44 mov 0x44(%eax),%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 1081c7: c9 leave <== NOT EXECUTED 1081c8: c3 ret <== NOT EXECUTED 1081c9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_NAME_MAX: return_value = the_limits->name_max; break; case _PC_PATH_MAX: return_value = the_limits->path_max; 1081cc: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 1081cf: c9 leave <== NOT EXECUTED 1081d0: c3 ret <== NOT EXECUTED 1081d1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_MAX_INPUT: return_value = the_limits->max_input; break; case _PC_NAME_MAX: return_value = the_limits->name_max; 1081d4: 8b 40 3c mov 0x3c(%eax),%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 1081d7: c9 leave <== NOT EXECUTED 1081d8: c3 ret <== NOT EXECUTED 1081d9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED break; case _PC_MAX_CANON: return_value = the_limits->max_canon; break; case _PC_MAX_INPUT: return_value = the_limits->max_input; 1081dc: 8b 40 38 mov 0x38(%eax),%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 1081df: c9 leave <== NOT EXECUTED 1081e0: c3 ret <== NOT EXECUTED 1081e1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED switch ( name ) { case _PC_LINK_MAX: return_value = the_limits->link_max; break; case _PC_MAX_CANON: return_value = the_limits->max_canon; 1081e4: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 1081e7: c9 leave <== NOT EXECUTED 1081e8: c3 ret <== NOT EXECUTED 1081e9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options; switch ( name ) { case _PC_LINK_MAX: return_value = the_limits->link_max; 1081ec: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 1081ef: c9 leave <== NOT EXECUTED 1081f0: c3 ret <== NOT EXECUTED 1081f1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED rtems_libio_t *iop; rtems_filesystem_limits_and_options_t *the_limits; rtems_libio_check_fd(fd); iop = rtems_libio_iop(fd); rtems_libio_check_is_open(iop); 1081f4: e8 3f af 00 00 call 113138 <__errno> <== NOT EXECUTED 1081f9: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 1081ff: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); break; } return return_value; } 108204: c9 leave <== NOT EXECUTED 108205: c3 ret <== NOT EXECUTED 001070a0 : void free( void *ptr ) { MSBUMP(free_calls, 1); 1070a0: 55 push %ebp <== NOT EXECUTED 1070a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1070a3: 53 push %ebx <== NOT EXECUTED 1070a4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1070a7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1070aa: ff 05 cc f6 11 00 incl 0x11f6cc <== NOT EXECUTED if ( !ptr ) 1070b0: 85 db test %ebx,%ebx <== NOT EXECUTED 1070b2: 74 4b je 1070ff <== NOT EXECUTED /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 1070b4: 83 3d 84 f9 11 00 03 cmpl $0x3,0x11f984 <== NOT EXECUTED 1070bb: 74 47 je 107104 <== NOT EXECUTED #endif /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 1070bd: a1 04 db 11 00 mov 0x11db04,%eax <== NOT EXECUTED 1070c2: 85 c0 test %eax,%eax <== NOT EXECUTED 1070c4: 74 0a je 1070d0 <== NOT EXECUTED (*rtems_malloc_statistics_helpers->at_free)(ptr); 1070c6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1070c9: 53 push %ebx <== NOT EXECUTED 1070ca: ff 50 08 call *0x8(%eax) <== NOT EXECUTED 1070cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( !_Protected_heap_Free( &RTEMS_Malloc_Heap, ptr ) ) { 1070d0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1070d3: 53 push %ebx <== NOT EXECUTED 1070d4: 68 60 f6 11 00 push $0x11f660 <== NOT EXECUTED 1070d9: e8 12 4d 00 00 call 10bdf0 <_Protected_heap_Free> <== NOT EXECUTED 1070de: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1070e1: 84 c0 test %al,%al <== NOT EXECUTED 1070e3: 75 1a jne 1070ff <== NOT EXECUTED printk( "Program heap: free of bad pointer %p -- range %p - %p \n", 1070e5: ff 35 7c f6 11 00 pushl 0x11f67c <== NOT EXECUTED 1070eb: ff 35 78 f6 11 00 pushl 0x11f678 <== NOT EXECUTED 1070f1: 53 push %ebx <== NOT EXECUTED 1070f2: 68 b8 8e 11 00 push $0x118eb8 <== NOT EXECUTED 1070f7: e8 f8 0c 00 00 call 107df4 <== NOT EXECUTED 1070fc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED RTEMS_Malloc_Heap.begin, RTEMS_Malloc_Heap.end ); } } 1070ff: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 107102: c9 leave <== NOT EXECUTED 107103: c3 ret <== NOT EXECUTED /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 107104: e8 af 00 00 00 call 1071b8 <== NOT EXECUTED 107109: 84 c0 test %al,%al <== NOT EXECUTED 10710b: 75 b0 jne 1070bd <== NOT EXECUTED !malloc_is_system_state_OK() ) { malloc_deferred_free(ptr); 10710d: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED RTEMS_Malloc_Heap.begin, RTEMS_Malloc_Heap.end ); } } 107110: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 107113: c9 leave <== NOT EXECUTED * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && !malloc_is_system_state_OK() ) { malloc_deferred_free(ptr); 107114: e9 df 00 00 00 jmp 1071f8 <== NOT EXECUTED 00124eb0 : * NOTE: this must be called with * thread dispatching disabled! */ static void free_user_env(void *venv) { 124eb0: 55 push %ebp <== NOT EXECUTED 124eb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124eb3: 53 push %ebx <== NOT EXECUTED 124eb4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 124eb7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_user_env_t *env = (rtems_user_env_t*) venv ; if (env != &rtems_global_user_env 124eba: 81 fb 40 26 16 00 cmp $0x162640,%ebx <== NOT EXECUTED 124ec0: 74 42 je 124f04 <== NOT EXECUTED #ifdef HAVE_USERENV_REFCNT && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); 124ec2: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 124ec5: 85 c0 test %eax,%eax <== NOT EXECUTED 124ec7: 74 13 je 124edc <== NOT EXECUTED 124ec9: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 124ecc: 85 d2 test %edx,%edx <== NOT EXECUTED 124ece: 74 0c je 124edc <== NOT EXECUTED 124ed0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124ed3: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 124ed6: 50 push %eax <== NOT EXECUTED 124ed7: ff d2 call *%edx <== NOT EXECUTED 124ed9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &env->root_directory); 124edc: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 124edf: 85 c0 test %eax,%eax <== NOT EXECUTED 124ee1: 74 13 je 124ef6 <== NOT EXECUTED 124ee3: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 124ee6: 85 d2 test %edx,%edx <== NOT EXECUTED 124ee8: 74 0c je 124ef6 <== NOT EXECUTED 124eea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124eed: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 124ef0: 50 push %eax <== NOT EXECUTED 124ef1: ff d2 call *%edx <== NOT EXECUTED 124ef3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free(env); 124ef6: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 124ef9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 124efc: c9 leave <== NOT EXECUTED && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); rtems_filesystem_freenode( &env->root_directory); free(env); 124efd: e9 6e 64 fe ff jmp 10b370 <== NOT EXECUTED 124f02: 66 90 xchg %ax,%ax <== NOT EXECUTED } } 124f04: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 124f07: c9 leave <== NOT EXECUTED 124f08: c3 ret <== NOT EXECUTED 00116f98 : int fstat( int fd, struct stat *sbuf ) { 116f98: 55 push %ebp <== NOT EXECUTED 116f99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116f9b: 57 push %edi <== NOT EXECUTED 116f9c: 56 push %esi <== NOT EXECUTED 116f9d: 53 push %ebx <== NOT EXECUTED 116f9e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116fa1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 116fa4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) 116fa7: 85 f6 test %esi,%esi <== NOT EXECUTED 116fa9: 74 7a je 117025 <== NOT EXECUTED /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); 116fab: 3b 15 00 b1 11 00 cmp 0x11b100,%edx <== NOT EXECUTED 116fb1: 73 4d jae 117000 <== NOT EXECUTED 116fb3: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 116fb6: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 116fb9: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 116fc0: 03 1d 30 f6 11 00 add 0x11f630,%ebx <== NOT EXECUTED rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 116fc6: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 116fca: 74 34 je 117000 <== NOT EXECUTED if ( !iop->handlers ) 116fcc: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 116fcf: 85 c0 test %eax,%eax <== NOT EXECUTED 116fd1: 74 2d je 117000 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fstat_h ) 116fd3: 8b 40 18 mov 0x18(%eax),%eax <== NOT EXECUTED 116fd6: 85 c0 test %eax,%eax <== NOT EXECUTED 116fd8: 74 3e je 117018 <== NOT EXECUTED /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); 116fda: b9 4c 00 00 00 mov $0x4c,%ecx <== NOT EXECUTED 116fdf: 31 c0 xor %eax,%eax <== NOT EXECUTED 116fe1: 89 f7 mov %esi,%edi <== NOT EXECUTED 116fe3: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf ); 116fe5: 8b 53 30 mov 0x30(%ebx),%edx <== NOT EXECUTED 116fe8: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 116feb: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 116fee: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 116ff1: 8b 4a 18 mov 0x18(%edx),%ecx <== NOT EXECUTED } 116ff4: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 116ff7: 5b pop %ebx <== NOT EXECUTED 116ff8: 5e pop %esi <== NOT EXECUTED 116ff9: 5f pop %edi <== NOT EXECUTED 116ffa: c9 leave <== NOT EXECUTED * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf ); 116ffb: ff e1 jmp *%ecx <== NOT EXECUTED 116ffd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 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 ); 117000: e8 7b 9c ff ff call 110c80 <__errno> <== NOT EXECUTED 117005: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf ); } 11700b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 117010: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 117013: 5b pop %ebx <== NOT EXECUTED 117014: 5e pop %esi <== NOT EXECUTED 117015: 5f pop %edi <== NOT EXECUTED 117016: c9 leave <== NOT EXECUTED 117017: c3 ret <== NOT EXECUTED if ( !iop->handlers ) rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fstat_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 117018: e8 63 9c ff ff call 110c80 <__errno> <== NOT EXECUTED 11701d: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 117023: eb e6 jmp 11700b <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) rtems_set_errno_and_return_minus_one( EFAULT ); 117025: e8 56 9c ff ff call 110c80 <__errno> <== NOT EXECUTED 11702a: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 117030: eb d9 jmp 11700b <== NOT EXECUTED 0012399c : #include int fsync( int fd ) { 12399c: 55 push %ebp <== NOT EXECUTED 12399d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12399f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1239a2: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 1239a5: 3b 15 40 90 14 00 cmp 0x149040,%edx <== NOT EXECUTED 1239ab: 73 33 jae 1239e0 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 1239ad: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 1239b0: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 1239b3: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 1239b6: 03 05 58 1d 16 00 add 0x161d58,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 1239bc: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 1239bf: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 1239c2: 74 1c je 1239e0 <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 1239c4: 83 e2 04 and $0x4,%edx <== NOT EXECUTED 1239c7: 74 2b je 1239f4 <== NOT EXECUTED /* * Now process the fsync(). */ if ( !iop->handlers ) 1239c9: 8b 50 30 mov 0x30(%eax),%edx <== NOT EXECUTED 1239cc: 85 d2 test %edx,%edx <== NOT EXECUTED 1239ce: 74 10 je 1239e0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fsync_h ) 1239d0: 8b 4a 28 mov 0x28(%edx),%ecx <== NOT EXECUTED 1239d3: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1239d5: 74 2a je 123a01 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->fsync_h)( iop ); 1239d7: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 1239da: c9 leave <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fsync_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->fsync_h)( iop ); 1239db: ff e1 jmp *%ecx <== NOT EXECUTED 1239dd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Now process the fsync(). */ if ( !iop->handlers ) rtems_set_errno_and_return_minus_one( EBADF ); 1239e0: e8 6f de 00 00 call 131854 <__errno> <== NOT EXECUTED 1239e5: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED if ( !iop->handlers->fsync_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->fsync_h)( iop ); } 1239eb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1239f0: c9 leave <== NOT EXECUTED 1239f1: c3 ret <== NOT EXECUTED 1239f2: 66 90 xchg %ax,%ax <== 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 ); 1239f4: e8 5b de 00 00 call 131854 <__errno> <== NOT EXECUTED 1239f9: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1239ff: eb ea jmp 1239eb <== NOT EXECUTED if ( !iop->handlers ) rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fsync_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 123a01: e8 4e de 00 00 call 131854 <__errno> <== NOT EXECUTED 123a06: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 123a0c: eb dd jmp 1239eb <== NOT EXECUTED 0010e5c8 : int ftruncate( int fd, off_t length ) { 10e5c8: 55 push %ebp <== NOT EXECUTED 10e5c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e5cb: 57 push %edi <== NOT EXECUTED 10e5cc: 56 push %esi <== NOT EXECUTED 10e5cd: 53 push %ebx <== NOT EXECUTED 10e5ce: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10e5d1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd ); 10e5d4: 3b 15 00 b1 11 00 cmp 0x11b100,%edx <== NOT EXECUTED 10e5da: 73 64 jae 10e640 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 10e5dc: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10e5df: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 10e5e2: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 10e5e9: 03 1d 30 f6 11 00 add 0x11f630,%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 10e5ef: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 10e5f3: 74 4b je 10e640 <== NOT EXECUTED /* * Make sure we are not working on a directory */ loc = iop->pathinfo; 10e5f5: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 10e5f8: 8d 73 10 lea 0x10(%ebx),%esi <== NOT EXECUTED 10e5fb: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10e600: 89 d7 mov %edx,%edi <== NOT EXECUTED 10e602: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !loc.ops->node_type_h ) 10e604: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10e607: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 10e60a: 85 c0 test %eax,%eax <== NOT EXECUTED 10e60c: 74 5a je 10e668 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) 10e60e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e611: 52 push %edx <== NOT EXECUTED 10e612: ff d0 call *%eax <== NOT EXECUTED 10e614: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e617: 48 dec %eax <== NOT EXECUTED 10e618: 74 60 je 10e67a <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EISDIR ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10e61a: f6 43 0c 04 testb $0x4,0xc(%ebx) <== NOT EXECUTED 10e61e: 74 34 je 10e654 <== NOT EXECUTED if ( !iop->handlers->ftruncate_h ) 10e620: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10e623: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED 10e626: 85 c0 test %eax,%eax <== NOT EXECUTED 10e628: 74 3e je 10e668 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->ftruncate_h)( iop, length ); 10e62a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e62d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10e630: 53 push %ebx <== NOT EXECUTED 10e631: ff d0 call *%eax <== NOT EXECUTED 10e633: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10e636: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e639: 5b pop %ebx <== NOT EXECUTED 10e63a: 5e pop %esi <== NOT EXECUTED 10e63b: 5f pop %edi <== NOT EXECUTED 10e63c: c9 leave <== NOT EXECUTED 10e63d: c3 ret <== NOT EXECUTED 10e63e: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 10e640: e8 3b 26 00 00 call 110c80 <__errno> <== NOT EXECUTED 10e645: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10e64b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e650: eb e4 jmp 10e636 <== NOT EXECUTED 10e652: 66 90 xchg %ax,%ax <== 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 ); 10e654: e8 27 26 00 00 call 110c80 <__errno> <== NOT EXECUTED 10e659: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10e65f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e664: eb d0 jmp 10e636 <== NOT EXECUTED 10e666: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !iop->handlers->ftruncate_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 10e668: e8 13 26 00 00 call 110c80 <__errno> <== NOT EXECUTED 10e66d: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10e673: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e678: eb bc jmp 10e636 <== 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 ); 10e67a: e8 01 26 00 00 call 110c80 <__errno> <== NOT EXECUTED 10e67f: c7 00 15 00 00 00 movl $0x15,(%eax) <== NOT EXECUTED 10e685: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e68a: eb aa jmp 10e636 <== NOT EXECUTED 00123ad4 : char * getcwd ( char *pt, size_t size) { 123ad4: 55 push %ebp <== NOT EXECUTED 123ad5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123ad7: 57 push %edi <== NOT EXECUTED 123ad8: 56 push %esi <== NOT EXECUTED 123ad9: 53 push %ebx <== NOT EXECUTED 123ada: 81 ec 9c 00 00 00 sub $0x9c,%esp <== NOT EXECUTED 123ae0: 8b 45 0c mov 0xc(%ebp),%eax <== 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) 123ae3: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 123ae6: 85 c9 test %ecx,%ecx <== NOT EXECUTED 123ae8: 0f 84 22 04 00 00 je 123f10 <== NOT EXECUTED { ptsize = 0; if (!size) 123aee: 85 c0 test %eax,%eax <== NOT EXECUTED 123af0: 0f 84 03 04 00 00 je 123ef9 <== NOT EXECUTED { errno = EINVAL; return (char *) NULL; } ept = pt + size; 123af6: 03 45 08 add 0x8(%ebp),%eax <== NOT EXECUTED 123af9: 89 45 98 mov %eax,-0x68(%ebp) <== NOT EXECUTED 123afc: c7 45 8c 00 00 00 00 movl $0x0,-0x74(%ebp) <== NOT EXECUTED { return (char *) NULL; } ept = pt + ptsize; } bpt = ept - 1; 123b03: 8b 45 98 mov -0x68(%ebp),%eax <== NOT EXECUTED 123b06: 48 dec %eax <== NOT EXECUTED 123b07: 89 45 84 mov %eax,-0x7c(%ebp) <== NOT EXECUTED *bpt = '\0'; 123b0a: 8b 55 98 mov -0x68(%ebp),%edx <== NOT EXECUTED 123b0d: c6 42 ff 00 movb $0x0,-0x1(%edx) <== 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))) 123b11: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123b14: 68 fc 03 00 00 push $0x3fc <== NOT EXECUTED 123b19: e8 76 7d fe ff call 10b894 <== NOT EXECUTED 123b1e: 89 c3 mov %eax,%ebx <== NOT EXECUTED 123b20: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123b23: 85 c0 test %eax,%eax <== NOT EXECUTED 123b25: 74 1f je 123b46 <== NOT EXECUTED { goto err; } eup = up + MAXPATHLEN; bup = up; up[0] = '.'; 123b27: c6 00 2e movb $0x2e,(%eax) <== NOT EXECUTED up[1] = '\0'; 123b2a: c6 40 01 00 movb $0x0,0x1(%eax) <== NOT EXECUTED /* Save root values, so know when to stop. */ if (stat ("/", &s)) 123b2e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 123b31: 8d 7d a8 lea -0x58(%ebp),%edi <== NOT EXECUTED 123b34: 57 push %edi <== NOT EXECUTED 123b35: 68 a3 51 14 00 push $0x1451a3 <== NOT EXECUTED 123b3a: e8 11 8e fe ff call 10c950 <== NOT EXECUTED 123b3f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123b42: 85 c0 test %eax,%eax <== NOT EXECUTED 123b44: 74 36 je 123b7c <== NOT EXECUTED /* FALLTHROUGH */ err: if(dir) (void) _closedir (dir); if (ptsize) 123b46: 8b 45 8c mov -0x74(%ebp),%eax <== NOT EXECUTED 123b49: 85 c0 test %eax,%eax <== NOT EXECUTED 123b4b: 75 1f jne 123b6c <== NOT EXECUTED free (pt); free (up); 123b4d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123b50: 53 push %ebx <== NOT EXECUTED 123b51: e8 1a 78 fe ff call 10b370 <== NOT EXECUTED 123b56: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp) <== NOT EXECUTED 123b5d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return (char *) NULL; } 123b60: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 123b63: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 123b66: 5b pop %ebx <== NOT EXECUTED 123b67: 5e pop %esi <== NOT EXECUTED 123b68: 5f pop %edi <== NOT EXECUTED 123b69: c9 leave <== NOT EXECUTED 123b6a: c3 ret <== NOT EXECUTED 123b6b: 90 nop <== NOT EXECUTED err: if(dir) (void) _closedir (dir); if (ptsize) free (pt); 123b6c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123b6f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 123b72: e8 f9 77 fe ff call 10b370 <== NOT EXECUTED 123b77: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123b7a: eb d1 jmp 123b4d <== NOT EXECUTED if (!(up = (char *) malloc (upsize = 1024 - 4))) { goto err; } eup = up + MAXPATHLEN; 123b7c: 8d 83 00 04 00 00 lea 0x400(%ebx),%eax <== NOT EXECUTED 123b82: 89 45 9c mov %eax,-0x64(%ebp) <== NOT EXECUTED up[1] = '\0'; /* Save root values, so know when to stop. */ if (stat ("/", &s)) goto err; root_dev = s.st_dev; 123b85: 8b 55 a8 mov -0x58(%ebp),%edx <== NOT EXECUTED 123b88: 89 95 68 ff ff ff mov %edx,-0x98(%ebp) <== NOT EXECUTED 123b8e: 8b 7d ac mov -0x54(%ebp),%edi <== NOT EXECUTED 123b91: 89 bd 64 ff ff ff mov %edi,-0x9c(%ebp) <== NOT EXECUTED root_ino = s.st_ino; 123b97: 8b 45 b0 mov -0x50(%ebp),%eax <== NOT EXECUTED 123b9a: 89 45 88 mov %eax,-0x78(%ebp) <== NOT EXECUTED errno = 0; /* XXX readdir has no error return. */ 123b9d: e8 b2 dc 00 00 call 131854 <__errno> <== NOT EXECUTED 123ba2: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 123ba8: 89 de mov %ebx,%esi <== NOT EXECUTED 123baa: c7 45 80 01 00 00 00 movl $0x1,-0x80(%ebp) <== NOT EXECUTED 123bb1: c7 45 90 fc 03 00 00 movl $0x3fc,-0x70(%ebp) <== NOT EXECUTED for (first = 1;; first = 0) { /* Stat the current level. */ if (_stat (up, &s)) 123bb8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 123bbb: 8d 55 a8 lea -0x58(%ebp),%edx <== NOT EXECUTED 123bbe: 52 push %edx <== NOT EXECUTED 123bbf: 53 push %ebx <== NOT EXECUTED 123bc0: e8 8b 8d fe ff call 10c950 <== NOT EXECUTED 123bc5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123bc8: 85 c0 test %eax,%eax <== NOT EXECUTED 123bca: 0f 85 76 ff ff ff jne 123b46 <== NOT EXECUTED goto err; /* Save current node values. */ ino = s.st_ino; 123bd0: 8b 7d b0 mov -0x50(%ebp),%edi <== NOT EXECUTED 123bd3: 89 bd 7c ff ff ff mov %edi,-0x84(%ebp) <== NOT EXECUTED dev = s.st_dev; 123bd9: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 123bdc: 89 85 60 ff ff ff mov %eax,-0xa0(%ebp) <== NOT EXECUTED 123be2: 8b 55 ac mov -0x54(%ebp),%edx <== NOT EXECUTED 123be5: 89 95 5c ff ff ff mov %edx,-0xa4(%ebp) <== NOT EXECUTED /* Check for reaching root. */ if (root_dev == dev && root_ino == ino) 123beb: 8b 95 64 ff ff ff mov -0x9c(%ebp),%edx <== NOT EXECUTED 123bf1: 33 95 5c ff ff ff xor -0xa4(%ebp),%edx <== NOT EXECUTED 123bf7: 8b 85 68 ff ff ff mov -0x98(%ebp),%eax <== NOT EXECUTED 123bfd: 33 85 60 ff ff ff xor -0xa0(%ebp),%eax <== NOT EXECUTED 123c03: 09 c2 or %eax,%edx <== NOT EXECUTED 123c05: 0f 84 b1 02 00 00 je 123ebc <== 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) 123c0b: 8d 86 04 04 00 00 lea 0x404(%esi),%eax <== NOT EXECUTED 123c11: 39 45 9c cmp %eax,-0x64(%ebp) <== NOT EXECUTED 123c14: 77 26 ja 123c3c <== NOT EXECUTED { if (!(up = (char *) realloc (up, upsize *= 2))) 123c16: d1 65 90 shll -0x70(%ebp) <== NOT EXECUTED 123c19: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 123c1c: ff 75 90 pushl -0x70(%ebp) <== NOT EXECUTED 123c1f: 53 push %ebx <== NOT EXECUTED 123c20: e8 3f 8c fe ff call 10c864 <== NOT EXECUTED 123c25: 89 c3 mov %eax,%ebx <== NOT EXECUTED 123c27: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123c2a: 85 c0 test %eax,%eax <== NOT EXECUTED 123c2c: 0f 84 14 ff ff ff je 123b46 <== NOT EXECUTED { goto err; } bup = up; eup = up + upsize; 123c32: 8b 45 90 mov -0x70(%ebp),%eax <== NOT EXECUTED 123c35: 01 d8 add %ebx,%eax <== NOT EXECUTED 123c37: 89 45 9c mov %eax,-0x64(%ebp) <== NOT EXECUTED 123c3a: 89 de mov %ebx,%esi <== NOT EXECUTED } *bup++ = '.'; 123c3c: c6 06 2e movb $0x2e,(%esi) <== NOT EXECUTED *bup++ = '.'; 123c3f: c6 46 01 2e movb $0x2e,0x1(%esi) <== NOT EXECUTED 123c43: 8d 7e 02 lea 0x2(%esi),%edi <== NOT EXECUTED *bup = '\0'; 123c46: c6 46 02 00 movb $0x0,0x2(%esi) <== NOT EXECUTED /* Open and stat parent directory. */ if (!(dir = _opendir (up)) || _fstat (__dirfd (dir), &s)) 123c4a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123c4d: 53 push %ebx <== NOT EXECUTED 123c4e: e8 c1 11 00 00 call 124e14 <== NOT EXECUTED 123c53: 89 85 78 ff ff ff mov %eax,-0x88(%ebp) <== NOT EXECUTED 123c59: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123c5c: 85 c0 test %eax,%eax <== NOT EXECUTED 123c5e: 0f 84 e2 fe ff ff je 123b46 <== NOT EXECUTED 123c64: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 123c67: 8d 55 a8 lea -0x58(%ebp),%edx <== NOT EXECUTED 123c6a: 52 push %edx <== NOT EXECUTED 123c6b: ff 30 pushl (%eax) <== NOT EXECUTED 123c6d: e8 76 fc ff ff call 1238e8 <== NOT EXECUTED 123c72: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123c75: 85 c0 test %eax,%eax <== NOT EXECUTED 123c77: 0f 85 ff 01 00 00 jne 123e7c <== NOT EXECUTED goto err; /* Add trailing slash for next directory. */ *bup++ = '/'; 123c7d: c6 07 2f movb $0x2f,(%edi) <== NOT EXECUTED 123c80: 83 c6 03 add $0x3,%esi <== 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) 123c83: 8b 95 5c ff ff ff mov -0xa4(%ebp),%edx <== NOT EXECUTED 123c89: 33 55 ac xor -0x54(%ebp),%edx <== NOT EXECUTED 123c8c: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax <== NOT EXECUTED 123c92: 33 45 a8 xor -0x58(%ebp),%eax <== NOT EXECUTED 123c95: 09 c2 or %eax,%edx <== NOT EXECUTED 123c97: 0f 84 8f 00 00 00 je 123d2c <== NOT EXECUTED 123c9d: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) <== NOT EXECUTED } } else for (;;) { if (!(dp = _readdir (dir))) 123ca4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123ca7: ff b5 78 ff ff ff pushl -0x88(%ebp) <== NOT EXECUTED 123cad: e8 0a 14 00 00 call 1250bc <== NOT EXECUTED 123cb2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123cb5: 85 c0 test %eax,%eax <== NOT EXECUTED 123cb7: 0f 84 df 01 00 00 je 123e9c <== NOT EXECUTED goto notfound; if (ISDOT (dp)) 123cbd: 80 78 0c 2e cmpb $0x2e,0xc(%eax) <== NOT EXECUTED 123cc1: 75 10 jne 123cd3 <== NOT EXECUTED 123cc3: 8a 50 0d mov 0xd(%eax),%dl <== NOT EXECUTED 123cc6: 84 d2 test %dl,%dl <== NOT EXECUTED 123cc8: 74 da je 123ca4 <== NOT EXECUTED 123cca: 80 fa 2e cmp $0x2e,%dl <== NOT EXECUTED 123ccd: 0f 84 8d 01 00 00 je 123e60 <== NOT EXECUTED continue; bcopy (dp->d_name, bup, strlen (dp->d_name) + 1); 123cd3: 83 c0 0c add $0xc,%eax <== NOT EXECUTED 123cd6: 89 85 58 ff ff ff mov %eax,-0xa8(%ebp) <== NOT EXECUTED 123cdc: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 123ce1: 89 c7 mov %eax,%edi <== NOT EXECUTED 123ce3: 31 c0 xor %eax,%eax <== NOT EXECUTED 123ce5: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 123ce7: f7 d1 not %ecx <== NOT EXECUTED 123ce9: 57 push %edi <== NOT EXECUTED 123cea: 51 push %ecx <== NOT EXECUTED 123ceb: ff b5 58 ff ff ff pushl -0xa8(%ebp) <== NOT EXECUTED 123cf1: 56 push %esi <== NOT EXECUTED 123cf2: e8 59 fd 00 00 call 133a50 <== NOT EXECUTED /* Save the first error for later. */ if (stat (up, &s)) 123cf7: 58 pop %eax <== NOT EXECUTED 123cf8: 5a pop %edx <== NOT EXECUTED 123cf9: 8d 45 a8 lea -0x58(%ebp),%eax <== NOT EXECUTED 123cfc: 50 push %eax <== NOT EXECUTED 123cfd: 53 push %ebx <== NOT EXECUTED 123cfe: e8 4d 8c fe ff call 10c950 <== NOT EXECUTED 123d03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123d06: 85 c0 test %eax,%eax <== NOT EXECUTED 123d08: 0f 84 12 01 00 00 je 123e20 <== NOT EXECUTED { if (!save_errno) 123d0e: 8b 45 94 mov -0x6c(%ebp),%eax <== NOT EXECUTED 123d11: 85 c0 test %eax,%eax <== NOT EXECUTED 123d13: 0f 84 37 01 00 00 je 123e50 <== NOT EXECUTED save_errno = errno; errno = 0; 123d19: e8 36 db 00 00 call 131854 <__errno> <== NOT EXECUTED 123d1e: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 123d24: e9 7b ff ff ff jmp 123ca4 <== NOT EXECUTED 123d29: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED save_errno = 0; if (s.st_dev == dev) { for (;;) { if (!(dp = _readdir (dir))) 123d2c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123d2f: ff b5 78 ff ff ff pushl -0x88(%ebp) <== NOT EXECUTED 123d35: e8 82 13 00 00 call 1250bc <== NOT EXECUTED 123d3a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123d3d: 85 c0 test %eax,%eax <== NOT EXECUTED 123d3f: 0f 84 4d 01 00 00 je 123e92 <== NOT EXECUTED goto notfound; if (dp->d_ino == ino) 123d45: 8b bd 7c ff ff ff mov -0x84(%ebp),%edi <== NOT EXECUTED 123d4b: 39 38 cmp %edi,(%eax) <== NOT EXECUTED 123d4d: 75 dd jne 123d2c <== NOT EXECUTED 123d4f: 83 c0 0c add $0xc,%eax <== NOT EXECUTED 123d52: 89 85 58 ff ff ff mov %eax,-0xa8(%ebp) <== NOT EXECUTED /* * Check for length of the current name, preceding slash, * leading slash. */ if (bpt - pt <= strlen (dp->d_name) + (first ? 1 : 2)) 123d58: 8b 7d 84 mov -0x7c(%ebp),%edi <== NOT EXECUTED 123d5b: 2b 7d 08 sub 0x8(%ebp),%edi <== NOT EXECUTED 123d5e: 89 7d a0 mov %edi,-0x60(%ebp) <== NOT EXECUTED 123d61: 31 c0 xor %eax,%eax <== NOT EXECUTED 123d63: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 123d68: 8b bd 58 ff ff ff mov -0xa8(%ebp),%edi <== NOT EXECUTED 123d6e: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 123d70: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 123d73: f7 d8 neg %eax <== NOT EXECUTED 123d75: 29 c8 sub %ecx,%eax <== NOT EXECUTED 123d77: 39 45 a0 cmp %eax,-0x60(%ebp) <== NOT EXECUTED 123d7a: 77 50 ja 123dcc <== NOT EXECUTED { size_t len, off; if (!ptsize) 123d7c: 8b 7d 8c mov -0x74(%ebp),%edi <== NOT EXECUTED 123d7f: 85 ff test %edi,%edi <== NOT EXECUTED 123d81: 0f 84 e8 00 00 00 je 123e6f <== NOT EXECUTED errno = ERANGE; goto err; } off = bpt - pt; len = ept - bpt; if (!(pt = (char *) realloc (pt, ptsize *= 2))) 123d87: d1 65 8c shll -0x74(%ebp) <== NOT EXECUTED 123d8a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 123d8d: ff 75 8c pushl -0x74(%ebp) <== NOT EXECUTED 123d90: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 123d93: e8 cc 8a fe ff call 10c864 <== NOT EXECUTED 123d98: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 123d9b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123d9e: 85 c0 test %eax,%eax <== NOT EXECUTED 123da0: 0f 84 d6 00 00 00 je 123e7c <== NOT EXECUTED { errno = ERANGE; goto err; } off = bpt - pt; len = ept - bpt; 123da6: 8b 45 98 mov -0x68(%ebp),%eax <== NOT EXECUTED 123da9: 2b 45 84 sub -0x7c(%ebp),%eax <== NOT EXECUTED if (!(pt = (char *) realloc (pt, ptsize *= 2))) { goto err; } bpt = pt + off; ept = pt + ptsize; 123dac: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 123daf: 03 55 8c add -0x74(%ebp),%edx <== NOT EXECUTED 123db2: 89 55 98 mov %edx,-0x68(%ebp) <== NOT EXECUTED (void) bcopy (bpt, ept - len, len); 123db5: 29 c2 sub %eax,%edx <== NOT EXECUTED 123db7: 89 55 84 mov %edx,-0x7c(%ebp) <== NOT EXECUTED 123dba: 51 push %ecx <== NOT EXECUTED 123dbb: 50 push %eax <== NOT EXECUTED 123dbc: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 123dbf: 03 45 a0 add -0x60(%ebp),%eax <== NOT EXECUTED 123dc2: 50 push %eax <== NOT EXECUTED 123dc3: 52 push %edx <== NOT EXECUTED 123dc4: e8 87 fc 00 00 call 133a50 <== NOT EXECUTED 123dc9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED bpt = ept - len; } if (!first) 123dcc: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 123dcf: 85 c0 test %eax,%eax <== NOT EXECUTED 123dd1: 75 09 jne 123ddc <== NOT EXECUTED *--bpt = '/'; 123dd3: ff 4d 84 decl -0x7c(%ebp) <== NOT EXECUTED 123dd6: 8b 7d 84 mov -0x7c(%ebp),%edi <== NOT EXECUTED 123dd9: c6 07 2f movb $0x2f,(%edi) <== NOT EXECUTED bpt -= strlen (dp->d_name); 123ddc: 31 c0 xor %eax,%eax <== NOT EXECUTED 123dde: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 123de3: 8b bd 58 ff ff ff mov -0xa8(%ebp),%edi <== NOT EXECUTED 123de9: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 123deb: f7 d1 not %ecx <== NOT EXECUTED 123ded: 49 dec %ecx <== NOT EXECUTED 123dee: 29 4d 84 sub %ecx,-0x7c(%ebp) <== NOT EXECUTED bcopy (dp->d_name, bpt, strlen (dp->d_name)); 123df1: 50 push %eax <== NOT EXECUTED 123df2: 51 push %ecx <== NOT EXECUTED 123df3: ff b5 58 ff ff ff pushl -0xa8(%ebp) <== NOT EXECUTED 123df9: ff 75 84 pushl -0x7c(%ebp) <== NOT EXECUTED 123dfc: e8 4f fc 00 00 call 133a50 <== NOT EXECUTED (void) _closedir (dir); 123e01: 5f pop %edi <== NOT EXECUTED 123e02: ff b5 78 ff ff ff pushl -0x88(%ebp) <== NOT EXECUTED 123e08: e8 b3 b9 00 00 call 12f7c0 <== NOT EXECUTED dir = 0; /* Truncate any file name. */ *bup = '\0'; 123e0d: c6 06 00 movb $0x0,(%esi) <== NOT EXECUTED 123e10: c7 45 80 00 00 00 00 movl $0x0,-0x80(%ebp) <== NOT EXECUTED 123e17: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123e1a: e9 99 fd ff ff jmp 123bb8 <== NOT EXECUTED 123e1f: 90 nop <== NOT EXECUTED if (!save_errno) save_errno = errno; errno = 0; continue; } if (s.st_dev == dev && s.st_ino == ino) 123e20: 8b 95 5c ff ff ff mov -0xa4(%ebp),%edx <== NOT EXECUTED 123e26: 33 55 ac xor -0x54(%ebp),%edx <== NOT EXECUTED 123e29: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax <== NOT EXECUTED 123e2f: 33 45 a8 xor -0x58(%ebp),%eax <== NOT EXECUTED 123e32: 09 c2 or %eax,%edx <== NOT EXECUTED 123e34: 0f 85 6a fe ff ff jne 123ca4 <== NOT EXECUTED 123e3a: 8b 95 7c ff ff ff mov -0x84(%ebp),%edx <== NOT EXECUTED 123e40: 39 55 b0 cmp %edx,-0x50(%ebp) <== NOT EXECUTED 123e43: 0f 85 5b fe ff ff jne 123ca4 <== NOT EXECUTED 123e49: e9 0a ff ff ff jmp 123d58 <== NOT EXECUTED 123e4e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* Save the first error for later. */ if (stat (up, &s)) { if (!save_errno) save_errno = errno; 123e50: e8 ff d9 00 00 call 131854 <__errno> <== NOT EXECUTED 123e55: 8b 00 mov (%eax),%eax <== NOT EXECUTED 123e57: 89 45 94 mov %eax,-0x6c(%ebp) <== NOT EXECUTED 123e5a: e9 ba fe ff ff jmp 123d19 <== NOT EXECUTED 123e5f: 90 nop <== NOT EXECUTED else for (;;) { if (!(dp = _readdir (dir))) goto notfound; if (ISDOT (dp)) 123e60: 80 78 0e 00 cmpb $0x0,0xe(%eax) <== NOT EXECUTED 123e64: 0f 84 3a fe ff ff je 123ca4 <== NOT EXECUTED 123e6a: e9 64 fe ff ff jmp 123cd3 <== NOT EXECUTED { size_t len, off; if (!ptsize) { errno = ERANGE; 123e6f: e8 e0 d9 00 00 call 131854 <__errno> <== NOT EXECUTED 123e74: c7 00 22 00 00 00 movl $0x22,(%eax) <== NOT EXECUTED 123e7a: 66 90 xchg %ax,%ax <== NOT EXECUTED errno = save_errno ? save_errno : ENOENT; /* FALLTHROUGH */ err: if(dir) (void) _closedir (dir); 123e7c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123e7f: ff b5 78 ff ff ff pushl -0x88(%ebp) <== NOT EXECUTED 123e85: e8 36 b9 00 00 call 12f7c0 <== NOT EXECUTED 123e8a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123e8d: e9 b4 fc ff ff jmp 123b46 <== NOT EXECUTED (void) _closedir (dir); dir = 0; /* Truncate any file name. */ *bup = '\0'; } 123e92: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) <== NOT EXECUTED 123e99: 8d 76 00 lea 0x0(%esi),%esi <== 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) 123e9c: e8 b3 d9 00 00 call 131854 <__errno> <== NOT EXECUTED 123ea1: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 123ea3: 85 c9 test %ecx,%ecx <== NOT EXECUTED 123ea5: 75 d5 jne 123e7c <== NOT EXECUTED errno = save_errno ? save_errno : ENOENT; 123ea7: e8 a8 d9 00 00 call 131854 <__errno> <== NOT EXECUTED 123eac: 8b 55 94 mov -0x6c(%ebp),%edx <== NOT EXECUTED 123eaf: 85 d2 test %edx,%edx <== NOT EXECUTED 123eb1: 74 3d je 123ef0 <== NOT EXECUTED 123eb3: 8b 55 94 mov -0x6c(%ebp),%edx <== NOT EXECUTED 123eb6: 89 10 mov %edx,(%eax) <== NOT EXECUTED 123eb8: eb c2 jmp 123e7c <== NOT EXECUTED 123eba: 66 90 xchg %ax,%ax <== 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) 123ebc: 39 7d 88 cmp %edi,-0x78(%ebp) <== NOT EXECUTED 123ebf: 0f 85 46 fd ff ff jne 123c0b <== NOT EXECUTED { *--bpt = '/'; 123ec5: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 123ec8: 48 dec %eax <== NOT EXECUTED 123ec9: 8b 7d 84 mov -0x7c(%ebp),%edi <== NOT EXECUTED 123ecc: c6 47 ff 2f movb $0x2f,-0x1(%edi) <== 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); 123ed0: 52 push %edx <== NOT EXECUTED 123ed1: 29 45 98 sub %eax,-0x68(%ebp) <== NOT EXECUTED 123ed4: ff 75 98 pushl -0x68(%ebp) <== NOT EXECUTED 123ed7: 50 push %eax <== NOT EXECUTED 123ed8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 123edb: e8 70 fb 00 00 call 133a50 <== NOT EXECUTED free (up); 123ee0: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 123ee3: e8 88 74 fe ff call 10b370 <== NOT EXECUTED 123ee8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123eeb: e9 70 fc ff ff jmp 123b60 <== NOT EXECUTED * didn't find the current directory in its parent directory, set * errno to ENOENT. */ if (!errno) errno = save_errno ? save_errno : ENOENT; 123ef0: c7 45 94 02 00 00 00 movl $0x2,-0x6c(%ebp) <== NOT EXECUTED 123ef7: eb ba jmp 123eb3 <== NOT EXECUTED if (pt) { ptsize = 0; if (!size) { errno = EINVAL; 123ef9: e8 56 d9 00 00 call 131854 <__errno> <== NOT EXECUTED 123efe: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 123f04: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp) <== NOT EXECUTED 123f0b: e9 50 fc ff ff jmp 123b60 <== NOT EXECUTED } ept = pt + size; } else { if (!(pt = (char *) malloc (ptsize = 1024 - 4))) 123f10: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123f13: 68 fc 03 00 00 push $0x3fc <== NOT EXECUTED 123f18: e8 77 79 fe ff call 10b894 <== NOT EXECUTED 123f1d: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 123f20: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123f23: 85 c0 test %eax,%eax <== NOT EXECUTED 123f25: 0f 84 35 fc ff ff je 123b60 <== NOT EXECUTED { return (char *) NULL; } ept = pt + ptsize; 123f2b: 05 fc 03 00 00 add $0x3fc,%eax <== NOT EXECUTED 123f30: 89 45 98 mov %eax,-0x68(%ebp) <== NOT EXECUTED 123f33: c7 45 8c fc 03 00 00 movl $0x3fc,-0x74(%ebp) <== NOT EXECUTED 123f3a: e9 c4 fb ff ff jmp 123b03 <== NOT EXECUTED 0012fb40 : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 12fb40: 55 push %ebp <== NOT EXECUTED 12fb41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12fb43: 57 push %edi <== NOT EXECUTED 12fb44: 56 push %esi <== NOT EXECUTED 12fb45: 53 push %ebx <== NOT EXECUTED 12fb46: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 12fb49: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED /* * Get the file control block structure associated with the file descriptor */ iop = rtems_libio_iop( dd_fd ); 12fb4c: 3b 15 40 90 14 00 cmp 0x149040,%edx <== NOT EXECUTED 12fb52: 72 48 jb 12fb9c <== NOT EXECUTED 12fb54: 31 db xor %ebx,%ebx <== NOT EXECUTED /* * Make sure we are working on a directory */ loc = iop->pathinfo; 12fb56: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 12fb59: 8d 73 10 lea 0x10(%ebx),%esi <== NOT EXECUTED 12fb5c: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12fb61: 89 d7 mov %edx,%edi <== NOT EXECUTED 12fb63: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !loc.ops->node_type_h ) 12fb65: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 12fb68: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 12fb6b: 85 c0 test %eax,%eax <== NOT EXECUTED 12fb6d: 74 59 je 12fbc8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) 12fb6f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12fb72: 52 push %edx <== NOT EXECUTED 12fb73: ff d0 call *%eax <== NOT EXECUTED 12fb75: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12fb78: 48 dec %eax <== NOT EXECUTED 12fb79: 75 39 jne 12fbb4 <== NOT EXECUTED /* * Return the number of bytes that were actually transfered as a result * of the read attempt. */ if ( !iop->handlers->read_h ) 12fb7b: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 12fb7e: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 12fb81: 85 c0 test %eax,%eax <== NOT EXECUTED 12fb83: 74 43 je 12fbc8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->read_h)( iop, dd_buf, dd_len ); 12fb85: 52 push %edx <== NOT EXECUTED 12fb86: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 12fb89: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 12fb8c: 53 push %ebx <== NOT EXECUTED 12fb8d: ff d0 call *%eax <== NOT EXECUTED 12fb8f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 12fb92: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12fb95: 5b pop %ebx <== NOT EXECUTED 12fb96: 5e pop %esi <== NOT EXECUTED 12fb97: 5f pop %edi <== NOT EXECUTED 12fb98: c9 leave <== NOT EXECUTED 12fb99: c3 ret <== NOT EXECUTED 12fb9a: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Get the file control block structure associated with the file descriptor */ iop = rtems_libio_iop( dd_fd ); 12fb9c: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 12fb9f: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 12fba2: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 12fba9: 03 1d 58 1d 16 00 add 0x161d58,%ebx <== NOT EXECUTED 12fbaf: eb a5 jmp 12fb56 <== NOT EXECUTED 12fbb1: 8d 76 00 lea 0x0(%esi),%esi <== 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( ENOTDIR ); 12fbb4: e8 9b 1c 00 00 call 131854 <__errno> <== NOT EXECUTED 12fbb9: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 12fbbf: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12fbc4: eb cc jmp 12fb92 <== NOT EXECUTED 12fbc6: 66 90 xchg %ax,%ax <== NOT EXECUTED * 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 ); 12fbc8: e8 87 1c 00 00 call 131854 <__errno> <== NOT EXECUTED 12fbcd: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12fbd3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12fbd8: eb b8 jmp 12fb92 <== NOT EXECUTED 0010e68c : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ gid_t getegid( void ) { 10e68c: 55 push %ebp <== NOT EXECUTED 10e68d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e68f: a1 74 d5 11 00 mov 0x11d574,%eax <== NOT EXECUTED 10e694: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED return _POSIX_types_Egid; } 10e697: c9 leave <== NOT EXECUTED 10e698: c3 ret <== NOT EXECUTED 0010e69c : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ uid_t geteuid( void ) { 10e69c: 55 push %ebp <== NOT EXECUTED 10e69d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e69f: a1 74 d5 11 00 mov 0x11d574,%eax <== NOT EXECUTED 10e6a4: 66 8b 40 2e mov 0x2e(%eax),%ax <== NOT EXECUTED return _POSIX_types_Euid; } 10e6a8: c9 leave <== NOT EXECUTED 10e6a9: c3 ret <== NOT EXECUTED 00123f60 : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ gid_t getgid( void ) { 123f60: 55 push %ebp <== NOT EXECUTED 123f61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123f63: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED 123f68: 8b 40 2c mov 0x2c(%eax),%eax <== NOT EXECUTED return _POSIX_types_Gid; } 123f6b: c9 leave <== NOT EXECUTED 123f6c: c3 ret <== NOT EXECUTED 001244f0 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 1244f0: 55 push %ebp <== NOT EXECUTED 1244f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1244f3: 57 push %edi <== NOT EXECUTED 1244f4: 56 push %esi <== NOT EXECUTED 1244f5: 53 push %ebx <== NOT EXECUTED 1244f6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1244f9: 89 c7 mov %eax,%edi <== NOT EXECUTED 1244fb: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 1244fe: 89 cb mov %ecx,%ebx <== NOT EXECUTED FILE *fp; int match; init_etc_passwd_group(); 124500: e8 af fe ff ff call 1243b4 <== NOT EXECUTED if ((fp = fopen("/etc/group", "r")) == NULL) { 124505: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124508: 68 81 29 14 00 push $0x142981 <== NOT EXECUTED 12450d: 68 59 50 14 00 push $0x145059 <== NOT EXECUTED 124512: e8 f5 db 00 00 call 13210c <== NOT EXECUTED 124517: 89 c6 mov %eax,%esi <== NOT EXECUTED 124519: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12451c: 85 c0 test %eax,%eax <== NOT EXECUTED 12451e: 75 22 jne 124542 <== NOT EXECUTED 124520: e9 8b 00 00 00 jmp 1245b0 <== NOT EXECUTED 124525: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED errno = EINVAL; fclose(fp); return -1; } if (name) { match = (strcmp(grp->gr_name, name) == 0); 124528: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12452b: 57 push %edi <== NOT EXECUTED 12452c: ff 33 pushl (%ebx) <== NOT EXECUTED 12452e: e8 6d 17 01 00 call 135ca0 <== NOT EXECUTED 124533: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124536: 85 c0 test %eax,%eax <== NOT EXECUTED 124538: 0f 94 c0 sete %al <== NOT EXECUTED 12453b: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED } else { match = (grp->gr_gid == gid); } if (match) { 12453e: 85 c0 test %eax,%eax <== NOT EXECUTED 124540: 75 2e jne 124570 <== NOT EXECUTED if ((fp = fopen("/etc/group", "r")) == NULL) { errno = EINVAL; return -1; } for(;;) { if (!scangr(fp, grp, buffer, bufsize)) { 124542: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124545: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 124548: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 12454b: 89 da mov %ebx,%edx <== NOT EXECUTED 12454d: 89 f0 mov %esi,%eax <== NOT EXECUTED 12454f: e8 dc fb ff ff call 124130 <== NOT EXECUTED 124554: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124557: 85 c0 test %eax,%eax <== NOT EXECUTED 124559: 74 31 je 12458c <== NOT EXECUTED errno = EINVAL; fclose(fp); return -1; } if (name) { 12455b: 85 ff test %edi,%edi <== NOT EXECUTED 12455d: 75 c9 jne 124528 <== NOT EXECUTED match = (strcmp(grp->gr_name, name) == 0); } else { match = (grp->gr_gid == gid); 12455f: 0f b7 43 08 movzwl 0x8(%ebx),%eax <== NOT EXECUTED 124563: 3b 45 f0 cmp -0x10(%ebp),%eax <== NOT EXECUTED 124566: 0f 94 c0 sete %al <== NOT EXECUTED 124569: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED } if (match) { 12456c: 85 c0 test %eax,%eax <== NOT EXECUTED 12456e: 74 d2 je 124542 <== NOT EXECUTED fclose(fp); 124570: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124573: 56 push %esi <== NOT EXECUTED 124574: e8 27 d4 00 00 call 1319a0 <== NOT EXECUTED *result = grp; 124579: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 12457c: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 12457e: 31 c0 xor %eax,%eax <== NOT EXECUTED 124580: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } fclose(fp); errno = EINVAL; return -1; } 124583: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124586: 5b pop %ebx <== NOT EXECUTED 124587: 5e pop %esi <== NOT EXECUTED 124588: 5f pop %edi <== NOT EXECUTED 124589: c9 leave <== NOT EXECUTED 12458a: c3 ret <== NOT EXECUTED 12458b: 90 nop <== NOT EXECUTED errno = EINVAL; return -1; } for(;;) { if (!scangr(fp, grp, buffer, bufsize)) { errno = EINVAL; 12458c: e8 c3 d2 00 00 call 131854 <__errno> <== NOT EXECUTED 124591: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED fclose(fp); 124597: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12459a: 56 push %esi <== NOT EXECUTED 12459b: e8 00 d4 00 00 call 1319a0 <== NOT EXECUTED 1245a0: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1245a5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } fclose(fp); errno = EINVAL; return -1; } 1245a8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1245ab: 5b pop %ebx <== NOT EXECUTED 1245ac: 5e pop %esi <== NOT EXECUTED 1245ad: 5f pop %edi <== NOT EXECUTED 1245ae: c9 leave <== NOT EXECUTED 1245af: c3 ret <== NOT EXECUTED int match; init_etc_passwd_group(); if ((fp = fopen("/etc/group", "r")) == NULL) { errno = EINVAL; 1245b0: e8 9f d2 00 00 call 131854 <__errno> <== NOT EXECUTED 1245b5: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1245bb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1245c0: eb c1 jmp 124583 <== NOT EXECUTED 00124248 : return NULL; return p; } struct group *getgrent() { 124248: 55 push %ebp <== NOT EXECUTED 124249: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12424b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (group_fp == NULL) 12424e: a1 64 14 16 00 mov 0x161464,%eax <== NOT EXECUTED 124253: 85 c0 test %eax,%eax <== NOT EXECUTED 124255: 74 25 je 12427c <== NOT EXECUTED return NULL; if (!scangr(group_fp, &grent, grbuf, sizeof grbuf)) 124257: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12425a: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 12425f: b9 80 14 16 00 mov $0x161480,%ecx <== NOT EXECUTED 124264: ba 48 15 16 00 mov $0x161548,%edx <== NOT EXECUTED 124269: e8 c2 fe ff ff call 124130 <== NOT EXECUTED 12426e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124271: 85 c0 test %eax,%eax <== NOT EXECUTED 124273: 74 07 je 12427c <== NOT EXECUTED 124275: b8 48 15 16 00 mov $0x161548,%eax <== NOT EXECUTED return NULL; return &grent; } 12427a: c9 leave <== NOT EXECUTED 12427b: c3 ret <== NOT EXECUTED struct group *getgrent() { if (group_fp == NULL) return NULL; if (!scangr(group_fp, &grent, grbuf, sizeof grbuf)) 12427c: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; return &grent; } 12427e: c9 leave <== NOT EXECUTED 12427f: c3 ret <== NOT EXECUTED 001245ec : } struct group *getgrgid( gid_t gid ) { 1245ec: 55 push %ebp <== NOT EXECUTED 1245ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1245ef: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct group *p; if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p)) 1245f2: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 1245f5: 50 push %eax <== NOT EXECUTED 1245f6: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 1245fb: 68 80 14 16 00 push $0x161480 <== NOT EXECUTED 124600: 68 48 15 16 00 push $0x161548 <== NOT EXECUTED 124605: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED 124609: 50 push %eax <== NOT EXECUTED 12460a: e8 b5 ff ff ff call 1245c4 <== NOT EXECUTED 12460f: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 124612: 85 c0 test %eax,%eax <== NOT EXECUTED 124614: 75 06 jne 12461c <== NOT EXECUTED return NULL; return p; 124616: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 124619: c9 leave <== NOT EXECUTED 12461a: c3 ret <== NOT EXECUTED 12461b: 90 nop <== NOT EXECUTED gid_t gid ) { struct group *p; if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p)) 12461c: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; return p; } 12461e: c9 leave <== NOT EXECUTED 12461f: c3 ret <== NOT EXECUTED 001245c4 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 1245c4: 55 push %ebp <== NOT EXECUTED 1245c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1245c7: 53 push %ebx <== NOT EXECUTED 1245c8: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1245cb: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED return getgr_r(NULL, gid, grp, buffer, bufsize, result); 1245ce: 0f b7 55 08 movzwl 0x8(%ebp),%edx <== NOT EXECUTED 1245d2: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 1245d5: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 1245d8: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1245db: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1245de: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 1245e1: 31 c0 xor %eax,%eax <== NOT EXECUTED } 1245e3: 5b pop %ebx <== NOT EXECUTED 1245e4: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct group **result ) { return getgr_r(NULL, gid, grp, buffer, bufsize, result); 1245e5: e9 06 ff ff ff jmp 1244f0 <== NOT EXECUTED 00124648 : } struct group *getgrnam( const char *name ) { 124648: 55 push %ebp <== NOT EXECUTED 124649: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12464b: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct group *p; if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p)) 12464e: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 124651: 50 push %eax <== NOT EXECUTED 124652: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 124657: 68 80 14 16 00 push $0x161480 <== NOT EXECUTED 12465c: 68 48 15 16 00 push $0x161548 <== NOT EXECUTED 124661: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124664: e8 b7 ff ff ff call 124620 <== NOT EXECUTED 124669: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 12466c: 85 c0 test %eax,%eax <== NOT EXECUTED 12466e: 75 08 jne 124678 <== NOT EXECUTED return NULL; return p; 124670: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 124673: c9 leave <== NOT EXECUTED 124674: c3 ret <== NOT EXECUTED 124675: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED const char *name ) { struct group *p; if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p)) 124678: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; return p; } 12467a: c9 leave <== NOT EXECUTED 12467b: c3 ret <== NOT EXECUTED 00124620 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 124620: 55 push %ebp <== NOT EXECUTED 124621: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124623: 53 push %ebx <== NOT EXECUTED 124624: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 124627: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 12462a: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED return getgr_r(name, 0, grp, buffer, bufsize, result); 12462d: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 124630: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED 124633: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 124636: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 124639: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 12463c: 31 d2 xor %edx,%edx <== NOT EXECUTED } 12463e: 5b pop %ebx <== NOT EXECUTED 12463f: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct group **result ) { return getgr_r(name, 0, grp, buffer, bufsize, result); 124640: e9 ab fe ff ff jmp 1244f0 <== NOT EXECUTED 00121880 : * * 4.1.1 Get Process and Parent Process IDs, P1003.1b-1993, p. 83 */ pid_t getpid( void ) { 121880: 55 push %ebp <== NOT EXECUTED 121881: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_Local_node; } 121883: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 121888: c9 leave <== NOT EXECUTED 121889: c3 ret <== NOT EXECUTED 001246b8 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 1246b8: 55 push %ebp <== NOT EXECUTED 1246b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1246bb: 57 push %edi <== NOT EXECUTED 1246bc: 56 push %esi <== NOT EXECUTED 1246bd: 53 push %ebx <== NOT EXECUTED 1246be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1246c1: 89 c7 mov %eax,%edi <== NOT EXECUTED 1246c3: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 1246c6: 89 cb mov %ecx,%ebx <== NOT EXECUTED FILE *fp; int match; init_etc_passwd_group(); 1246c8: e8 e7 fc ff ff call 1243b4 <== NOT EXECUTED if ((fp = fopen("/etc/passwd", "r")) == NULL) { 1246cd: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1246d0: 68 81 29 14 00 push $0x142981 <== NOT EXECUTED 1246d5: 68 4d 50 14 00 push $0x14504d <== NOT EXECUTED 1246da: e8 2d da 00 00 call 13210c <== NOT EXECUTED 1246df: 89 c6 mov %eax,%esi <== NOT EXECUTED 1246e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1246e4: 85 c0 test %eax,%eax <== NOT EXECUTED 1246e6: 75 22 jne 12470a <== NOT EXECUTED 1246e8: e9 8b 00 00 00 jmp 124778 <== NOT EXECUTED 1246ed: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED errno = EINVAL; fclose(fp); return -1; } if (name) { match = (strcmp(pwd->pw_name, name) == 0); 1246f0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1246f3: 57 push %edi <== NOT EXECUTED 1246f4: ff 33 pushl (%ebx) <== NOT EXECUTED 1246f6: e8 a5 15 01 00 call 135ca0 <== NOT EXECUTED 1246fb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1246fe: 85 c0 test %eax,%eax <== NOT EXECUTED 124700: 0f 94 c0 sete %al <== NOT EXECUTED 124703: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED } else { match = (pwd->pw_uid == uid); } if (match) { 124706: 85 c0 test %eax,%eax <== NOT EXECUTED 124708: 75 2e jne 124738 <== NOT EXECUTED if ((fp = fopen("/etc/passwd", "r")) == NULL) { errno = EINVAL; return -1; } for(;;) { if (!scanpw(fp, pwd, buffer, bufsize)) { 12470a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12470d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 124710: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 124713: 89 da mov %ebx,%edx <== NOT EXECUTED 124715: 89 f0 mov %esi,%eax <== NOT EXECUTED 124717: e8 64 fb ff ff call 124280 <== NOT EXECUTED 12471c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12471f: 85 c0 test %eax,%eax <== NOT EXECUTED 124721: 74 31 je 124754 <== NOT EXECUTED errno = EINVAL; fclose(fp); return -1; } if (name) { 124723: 85 ff test %edi,%edi <== NOT EXECUTED 124725: 75 c9 jne 1246f0 <== NOT EXECUTED match = (strcmp(pwd->pw_name, name) == 0); } else { match = (pwd->pw_uid == uid); 124727: 0f b7 43 08 movzwl 0x8(%ebx),%eax <== NOT EXECUTED 12472b: 3b 45 f0 cmp -0x10(%ebp),%eax <== NOT EXECUTED 12472e: 0f 94 c0 sete %al <== NOT EXECUTED 124731: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED } if (match) { 124734: 85 c0 test %eax,%eax <== NOT EXECUTED 124736: 74 d2 je 12470a <== NOT EXECUTED fclose(fp); 124738: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12473b: 56 push %esi <== NOT EXECUTED 12473c: e8 5f d2 00 00 call 1319a0 <== NOT EXECUTED *result = pwd; 124741: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 124744: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 124746: 31 c0 xor %eax,%eax <== NOT EXECUTED 124748: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } fclose(fp); errno = EINVAL; return -1; } 12474b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12474e: 5b pop %ebx <== NOT EXECUTED 12474f: 5e pop %esi <== NOT EXECUTED 124750: 5f pop %edi <== NOT EXECUTED 124751: c9 leave <== NOT EXECUTED 124752: c3 ret <== NOT EXECUTED 124753: 90 nop <== NOT EXECUTED errno = EINVAL; return -1; } for(;;) { if (!scanpw(fp, pwd, buffer, bufsize)) { errno = EINVAL; 124754: e8 fb d0 00 00 call 131854 <__errno> <== NOT EXECUTED 124759: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED fclose(fp); 12475f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124762: 56 push %esi <== NOT EXECUTED 124763: e8 38 d2 00 00 call 1319a0 <== NOT EXECUTED 124768: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12476d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } fclose(fp); errno = EINVAL; return -1; } 124770: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124773: 5b pop %ebx <== NOT EXECUTED 124774: 5e pop %esi <== NOT EXECUTED 124775: 5f pop %edi <== NOT EXECUTED 124776: c9 leave <== NOT EXECUTED 124777: c3 ret <== NOT EXECUTED int match; init_etc_passwd_group(); if ((fp = fopen("/etc/passwd", "r")) == NULL) { errno = EINVAL; 124778: e8 d7 d0 00 00 call 131854 <__errno> <== NOT EXECUTED 12477d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 124783: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 124788: eb c1 jmp 12474b <== NOT EXECUTED 0012437c : return NULL; return p; } struct passwd *getpwent() { 12437c: 55 push %ebp <== NOT EXECUTED 12437d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12437f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (passwd_fp == NULL) 124382: a1 64 13 16 00 mov 0x161364,%eax <== NOT EXECUTED 124387: 85 c0 test %eax,%eax <== NOT EXECUTED 124389: 74 25 je 1243b0 <== NOT EXECUTED return NULL; if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf)) 12438b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12438e: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 124393: b9 80 13 16 00 mov $0x161380,%ecx <== NOT EXECUTED 124398: ba 48 14 16 00 mov $0x161448,%edx <== NOT EXECUTED 12439d: e8 de fe ff ff call 124280 <== NOT EXECUTED 1243a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1243a5: 85 c0 test %eax,%eax <== NOT EXECUTED 1243a7: 74 07 je 1243b0 <== NOT EXECUTED 1243a9: b8 48 14 16 00 mov $0x161448,%eax <== NOT EXECUTED return NULL; return &pwent; } 1243ae: c9 leave <== NOT EXECUTED 1243af: c3 ret <== NOT EXECUTED struct passwd *getpwent() { if (passwd_fp == NULL) return NULL; if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf)) 1243b0: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; return &pwent; } 1243b2: c9 leave <== NOT EXECUTED 1243b3: c3 ret <== NOT EXECUTED 00124810 : } struct passwd *getpwnam( const char *name ) { 124810: 55 push %ebp <== NOT EXECUTED 124811: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124813: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct passwd *p; if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p)) 124816: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 124819: 50 push %eax <== NOT EXECUTED 12481a: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 12481f: 68 80 13 16 00 push $0x161380 <== NOT EXECUTED 124824: 68 48 14 16 00 push $0x161448 <== NOT EXECUTED 124829: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12482c: e8 b7 ff ff ff call 1247e8 <== NOT EXECUTED 124831: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 124834: 85 c0 test %eax,%eax <== NOT EXECUTED 124836: 75 08 jne 124840 <== NOT EXECUTED return NULL; return p; 124838: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 12483b: c9 leave <== NOT EXECUTED 12483c: c3 ret <== NOT EXECUTED 12483d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED const char *name ) { struct passwd *p; if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p)) 124840: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; return p; } 124842: c9 leave <== NOT EXECUTED 124843: c3 ret <== NOT EXECUTED 001247e8 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 1247e8: 55 push %ebp <== NOT EXECUTED 1247e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1247eb: 53 push %ebx <== NOT EXECUTED 1247ec: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1247ef: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1247f2: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED return getpw_r(name, 0, pwd, buffer, bufsize, result); 1247f5: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 1247f8: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED 1247fb: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 1247fe: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 124801: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 124804: 31 d2 xor %edx,%edx <== NOT EXECUTED } 124806: 5b pop %ebx <== NOT EXECUTED 124807: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct passwd **result ) { return getpw_r(name, 0, pwd, buffer, bufsize, result); 124808: e9 ab fe ff ff jmp 1246b8 <== NOT EXECUTED 001247b4 : } struct passwd *getpwuid( uid_t uid ) { 1247b4: 55 push %ebp <== NOT EXECUTED 1247b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1247b7: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct passwd *p; if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p)) 1247ba: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 1247bd: 50 push %eax <== NOT EXECUTED 1247be: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 1247c3: 68 80 13 16 00 push $0x161380 <== NOT EXECUTED 1247c8: 68 48 14 16 00 push $0x161448 <== NOT EXECUTED 1247cd: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED 1247d1: 50 push %eax <== NOT EXECUTED 1247d2: e8 b5 ff ff ff call 12478c <== NOT EXECUTED 1247d7: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1247da: 85 c0 test %eax,%eax <== NOT EXECUTED 1247dc: 75 06 jne 1247e4 <== NOT EXECUTED return NULL; return p; 1247de: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 1247e1: c9 leave <== NOT EXECUTED 1247e2: c3 ret <== NOT EXECUTED 1247e3: 90 nop <== NOT EXECUTED uid_t uid ) { struct passwd *p; if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p)) 1247e4: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; return p; } 1247e6: c9 leave <== NOT EXECUTED 1247e7: c3 ret <== NOT EXECUTED 0012478c : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 12478c: 55 push %ebp <== NOT EXECUTED 12478d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12478f: 53 push %ebx <== NOT EXECUTED 124790: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 124793: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED return getpw_r(NULL, uid, pwd, buffer, bufsize, result); 124796: 0f b7 55 08 movzwl 0x8(%ebp),%edx <== NOT EXECUTED 12479a: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 12479d: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 1247a0: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1247a3: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1247a6: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 1247a9: 31 c0 xor %eax,%eax <== NOT EXECUTED } 1247ab: 5b pop %ebx <== NOT EXECUTED 1247ac: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct passwd **result ) { return getpw_r(NULL, uid, pwd, buffer, bufsize, result); 1247ad: e9 06 ff ff ff jmp 1246b8 <== NOT EXECUTED 0010e6ac : int gettimeofday( struct timeval *tp, void * __tz ) { 10e6ac: 55 push %ebp <== NOT EXECUTED 10e6ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e6af: 56 push %esi <== NOT EXECUTED 10e6b0: 53 push %ebx <== NOT EXECUTED 10e6b1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10e6b4: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) { 10e6b7: 85 f6 test %esi,%esi <== NOT EXECUTED 10e6b9: 74 30 je 10e6eb <== NOT EXECUTED ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 10e6bb: 9c pushf <== NOT EXECUTED 10e6bc: fa cli <== NOT EXECUTED 10e6bd: 5b pop %ebx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 10e6be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e6c1: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10e6c4: 50 push %eax <== NOT EXECUTED 10e6c5: e8 d2 cb ff ff call 10b29c <_TOD_Get> <== NOT EXECUTED * begin at @a starting_address. 10e6ca: 53 push %ebx <== NOT EXECUTED 10e6cb: 9d popf <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon 10e6cc: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10e6cf: 89 06 mov %eax,(%esi) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory 10e6d1: b8 d3 4d 62 10 mov $0x10624dd3,%eax <== NOT EXECUTED 10e6d6: f7 65 f4 mull -0xc(%ebp) <== NOT EXECUTED 10e6d9: c1 ea 06 shr $0x6,%edx <== NOT EXECUTED 10e6dc: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED 10e6df: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e6e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X * do it. This puts us in good company. */ return 0; } 10e6e4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e6e7: 5b pop %ebx <== NOT EXECUTED 10e6e8: 5e pop %esi <== NOT EXECUTED 10e6e9: c9 leave <== NOT EXECUTED 10e6ea: c3 ret <== NOT EXECUTED void * __tz ) { /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) { errno = EFAULT; 10e6eb: e8 90 25 00 00 call 110c80 <__errno> <== NOT EXECUTED 10e6f0: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 10e6f6: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e6fb: eb e7 jmp 10e6e4 <== NOT EXECUTED 0010b464 : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ uid_t getuid( void ) { 10b464: 55 push %ebp <== NOT EXECUTED 10b465: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b467: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED 10b46c: 66 8b 40 2a mov 0x2a(%eax),%ax <== NOT EXECUTED return _POSIX_types_Uid; } 10b470: c9 leave <== NOT EXECUTED 10b471: c3 ret <== NOT EXECUTED 0012f388 : */ int imfs_dir_close( rtems_libio_t *iop ) { 12f388: 55 push %ebp <== NOT EXECUTED 12f389: 89 e5 mov %esp,%ebp <== NOT EXECUTED * and associated memory. At present the imfs_dir_close simply * returns a successful completion status. */ return 0; } 12f38b: 31 c0 xor %eax,%eax <== NOT EXECUTED 12f38d: c9 leave <== NOT EXECUTED 12f38e: c3 ret <== NOT EXECUTED 0012f390 : int imfs_dir_fstat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 12f390: 55 push %ebp <== NOT EXECUTED 12f391: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f393: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED rtems_chain_node *the_node; rtems_chain_control *the_chain; IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) loc->node_access; 12f396: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 12f399: 8b 10 mov (%eax),%edx <== NOT EXECUTED buf->st_dev = 0ll; 12f39b: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED 12f3a1: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED buf->st_ino = the_jnode->st_ino; 12f3a8: 8b 42 38 mov 0x38(%edx),%eax <== NOT EXECUTED 12f3ab: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED buf->st_mode = the_jnode->st_mode; 12f3ae: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 12f3b1: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED buf->st_nlink = the_jnode->st_nlink; 12f3b4: 8b 42 34 mov 0x34(%edx),%eax <== NOT EXECUTED 12f3b7: 66 89 41 10 mov %ax,0x10(%ecx) <== NOT EXECUTED buf->st_uid = the_jnode->st_uid; 12f3bb: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 12f3be: 66 89 41 12 mov %ax,0x12(%ecx) <== NOT EXECUTED buf->st_gid = the_jnode->st_gid; 12f3c2: 66 8b 42 3e mov 0x3e(%edx),%ax <== NOT EXECUTED 12f3c6: 66 89 41 14 mov %ax,0x14(%ecx) <== NOT EXECUTED buf->st_rdev = 0ll; 12f3ca: c7 41 18 00 00 00 00 movl $0x0,0x18(%ecx) <== NOT EXECUTED 12f3d1: c7 41 1c 00 00 00 00 movl $0x0,0x1c(%ecx) <== NOT EXECUTED buf->st_blksize = 0; 12f3d8: c7 41 3c 00 00 00 00 movl $0x0,0x3c(%ecx) <== NOT EXECUTED buf->st_blocks = 0; 12f3df: c7 41 40 00 00 00 00 movl $0x0,0x40(%ecx) <== NOT EXECUTED buf->st_atime = the_jnode->stat_atime; 12f3e6: 8b 42 40 mov 0x40(%edx),%eax <== NOT EXECUTED 12f3e9: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED buf->st_mtime = the_jnode->stat_mtime; 12f3ec: 8b 42 44 mov 0x44(%edx),%eax <== NOT EXECUTED 12f3ef: 89 41 2c mov %eax,0x2c(%ecx) <== NOT EXECUTED buf->st_ctime = the_jnode->stat_ctime; 12f3f2: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED 12f3f5: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED buf->st_size = 0; 12f3f8: c7 41 20 00 00 00 00 movl $0x0,0x20(%ecx) <== NOT EXECUTED the_chain = &the_jnode->info.directory.Entries; /* Run through the chain and count the number of directory entries */ /* that are subordinate to this directory node */ for ( the_node = the_chain->first ; 12f3ff: 8b 42 50 mov 0x50(%edx),%eax <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 12f402: 83 c2 54 add $0x54,%edx <== NOT EXECUTED !rtems_chain_is_tail( the_chain, the_node ) ; 12f405: 39 d0 cmp %edx,%eax <== NOT EXECUTED 12f407: 74 10 je 12f419 <== NOT EXECUTED 12f409: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_node = the_node->next ) { buf->st_size = buf->st_size + sizeof( struct dirent ); 12f40c: 81 41 20 0c 01 00 00 addl $0x10c,0x20(%ecx) <== NOT EXECUTED /* Run through the chain and count the number of directory entries */ /* that are subordinate to this directory node */ for ( the_node = the_chain->first ; !rtems_chain_is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 12f413: 8b 00 mov (%eax),%eax <== NOT EXECUTED the_chain = &the_jnode->info.directory.Entries; /* Run through the chain and count the number of directory entries */ /* that are subordinate to this directory node */ for ( the_node = the_chain->first ; !rtems_chain_is_tail( the_chain, the_node ) ; 12f415: 39 d0 cmp %edx,%eax <== NOT EXECUTED 12f417: 75 f3 jne 12f40c <== NOT EXECUTED buf->st_size = buf->st_size + sizeof( struct dirent ); } return 0; } 12f419: 31 c0 xor %eax,%eax <== NOT EXECUTED 12f41b: c9 leave <== NOT EXECUTED 12f41c: c3 ret <== NOT EXECUTED 0012f420 : off_t imfs_dir_lseek( rtems_libio_t *iop, off_t offset, int whence ) { 12f420: 55 push %ebp <== NOT EXECUTED 12f421: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f423: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12f426: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED switch( whence ) { 12f429: 83 7d 10 01 cmpl $0x1,0x10(%ebp) <== NOT EXECUTED 12f42d: 76 15 jbe 12f444 <== NOT EXECUTED break; case SEEK_END: /* Movement past the end of the directory via lseek */ /* is not a permitted operation */ default: rtems_set_errno_and_return_minus_one( EINVAL ); 12f42f: e8 20 24 00 00 call 131854 <__errno> <== NOT EXECUTED 12f434: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 12f43a: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED break; } return 0; } 12f43f: c9 leave <== NOT EXECUTED 12f440: c3 ret <== NOT EXECUTED 12f441: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { switch( whence ) { case SEEK_SET: /* absolute move from the start of the file */ case SEEK_CUR: /* relative move */ iop->offset = (iop->offset/sizeof(struct dirent)) * 12f444: b8 6b 4c a4 07 mov $0x7a44c6b,%eax <== NOT EXECUTED 12f449: f7 61 08 mull 0x8(%ecx) <== NOT EXECUTED 12f44c: c1 ea 03 shr $0x3,%edx <== NOT EXECUTED 12f44f: 89 d0 mov %edx,%eax <== NOT EXECUTED 12f451: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 12f454: 01 d0 add %edx,%eax <== NOT EXECUTED 12f456: 8d 04 42 lea (%edx,%eax,2),%eax <== NOT EXECUTED 12f459: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 12f45c: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED 12f45f: 31 c0 xor %eax,%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); break; } return 0; } 12f461: c9 leave <== NOT EXECUTED 12f462: c3 ret <== NOT EXECUTED 0012f364 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 12f364: 55 push %ebp <== NOT EXECUTED 12f365: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f367: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED IMFS_jnode_t *the_jnode; /* Is the node a directory ? */ the_jnode = (IMFS_jnode_t *) iop->file_info; if ( the_jnode->type != IMFS_DIRECTORY ) 12f36a: 8b 42 2c mov 0x2c(%edx),%eax <== NOT EXECUTED 12f36d: 83 78 4c 01 cmpl $0x1,0x4c(%eax) <== NOT EXECUTED 12f371: 74 09 je 12f37c <== NOT EXECUTED 12f373: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED return -1; /* It wasn't a directory --> return error */ iop->offset = 0; return 0; } 12f378: c9 leave <== NOT EXECUTED 12f379: c3 ret <== NOT EXECUTED 12f37a: 66 90 xchg %ax,%ax <== 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; 12f37c: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) <== NOT EXECUTED 12f383: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 12f385: c9 leave <== NOT EXECUTED 12f386: c3 ret <== NOT EXECUTED 0012f540 : ssize_t imfs_dir_read( rtems_libio_t *iop, void *buffer, size_t count ) { 12f540: 55 push %ebp <== NOT EXECUTED 12f541: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f543: 57 push %edi <== NOT EXECUTED 12f544: 56 push %esi <== NOT EXECUTED 12f545: 53 push %ebx <== NOT EXECUTED 12f546: 81 ec 3c 01 00 00 sub $0x13c,%esp <== NOT EXECUTED int current_entry; int first_entry; int last_entry; struct dirent tmp_dirent; the_jnode = (IMFS_jnode_t *)iop->file_info; 12f54c: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 12f54f: 8b 42 2c mov 0x2c(%edx),%eax <== NOT EXECUTED * to obtain the size of * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( 12f552: 8b 70 50 mov 0x50(%eax),%esi <== NOT EXECUTED 12f555: 89 b5 c0 fe ff ff mov %esi,-0x140(%ebp) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 12f55b: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 12f55e: 89 85 e0 fe ff ff mov %eax,-0x120(%ebp) <== NOT EXECUTED the_chain = &the_jnode->info.directory.Entries; if ( rtems_chain_is_empty( the_chain ) ) 12f564: 39 c6 cmp %eax,%esi <== NOT EXECUTED 12f566: 0f 84 04 01 00 00 je 12f670 <== NOT EXECUTED /* Move to the first of the desired directory entries */ the_node = the_chain->first; bytes_transferred = 0; first_entry = iop->offset; 12f56c: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 12f56f: 8b 7f 08 mov 0x8(%edi),%edi <== NOT EXECUTED 12f572: 89 bd d8 fe ff ff mov %edi,-0x128(%ebp) <== NOT EXECUTED /* 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); 12f578: ba 6b 4c a4 07 mov $0x7a44c6b,%edx <== NOT EXECUTED 12f57d: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 12f580: f7 e2 mul %edx <== NOT EXECUTED 12f582: c1 ea 03 shr $0x3,%edx <== NOT EXECUTED 12f585: 89 d0 mov %edx,%eax <== NOT EXECUTED 12f587: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 12f58a: 01 d0 add %edx,%eax <== NOT EXECUTED 12f58c: 8d 04 42 lea (%edx,%eax,2),%eax <== NOT EXECUTED 12f58f: 8d 04 87 lea (%edi,%eax,4),%eax <== NOT EXECUTED 12f592: 89 85 dc fe ff ff mov %eax,-0x124(%ebp) <== NOT EXECUTED /* The directory was not empty so try to move to the desired entry in chain*/ for ( current_entry = 0; current_entry < last_entry; 12f598: 85 c0 test %eax,%eax <== NOT EXECUTED 12f59a: 0f 8e d0 00 00 00 jle 12f670 <== NOT EXECUTED 12f5a0: c7 85 d4 fe ff ff 00 movl $0x0,-0x12c(%ebp) <== NOT EXECUTED 12f5a7: 00 00 00 <== NOT EXECUTED 12f5aa: 31 db xor %ebx,%ebx <== NOT EXECUTED 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 ); 12f5ac: 8d 95 e8 fe ff ff lea -0x118(%ebp),%edx <== NOT EXECUTED 12f5b2: 89 95 c4 fe ff ff mov %edx,-0x13c(%ebp) <== NOT EXECUTED 12f5b8: eb 34 jmp 12f5ee <== NOT EXECUTED 12f5ba: 66 90 xchg %ax,%ax <== NOT EXECUTED ); iop->offset = iop->offset + sizeof(struct dirent); bytes_transferred = bytes_transferred + sizeof( struct dirent ); } the_node = the_node->next; 12f5bc: 8b 85 c0 fe ff ff mov -0x140(%ebp),%eax <== NOT EXECUTED 12f5c2: 8b 00 mov (%eax),%eax <== NOT EXECUTED 12f5c4: 89 85 c0 fe ff ff mov %eax,-0x140(%ebp) <== NOT EXECUTED ssize_t imfs_dir_read( rtems_libio_t *iop, void *buffer, size_t count ) { 12f5ca: 81 c3 0c 01 00 00 add $0x10c,%ebx <== NOT EXECUTED 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; 12f5d0: 39 9d dc fe ff ff cmp %ebx,-0x124(%ebp) <== NOT EXECUTED 12f5d6: 0f 8e a0 00 00 00 jle 12f67c <== NOT EXECUTED current_entry = current_entry + sizeof(struct dirent) ){ if ( rtems_chain_is_tail( the_chain, the_node ) ){ 12f5dc: 8b b5 e0 fe ff ff mov -0x120(%ebp),%esi <== NOT EXECUTED 12f5e2: 39 b5 c0 fe ff ff cmp %esi,-0x140(%ebp) <== NOT EXECUTED 12f5e8: 0f 84 8e 00 00 00 je 12f67c <== NOT EXECUTED /* entry in the read */ return bytes_transferred; /* Indicate that there are no more */ /* entries to return */ } if( current_entry >= first_entry ) { 12f5ee: 39 9d d8 fe ff ff cmp %ebx,-0x128(%ebp) <== NOT EXECUTED 12f5f4: 7f c6 jg 12f5bc <== NOT EXECUTED /* Move the entry to the return buffer */ tmp_dirent.d_off = current_entry; 12f5f6: 89 9d ec fe ff ff mov %ebx,-0x114(%ebp) <== NOT EXECUTED tmp_dirent.d_reclen = sizeof( struct dirent ); 12f5fc: 66 c7 85 f0 fe ff ff movw $0x10c,-0x110(%ebp) <== NOT EXECUTED 12f603: 0c 01 <== NOT EXECUTED the_jnode = (IMFS_jnode_t *) the_node; tmp_dirent.d_ino = the_jnode->st_ino; 12f605: 8b bd c0 fe ff ff mov -0x140(%ebp),%edi <== NOT EXECUTED 12f60b: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 12f60e: 89 85 e8 fe ff ff mov %eax,-0x118(%ebp) <== NOT EXECUTED tmp_dirent.d_namlen = strlen( the_jnode->name ); 12f614: 89 fa mov %edi,%edx <== NOT EXECUTED 12f616: 83 c2 0c add $0xc,%edx <== NOT EXECUTED 12f619: 31 c0 xor %eax,%eax <== NOT EXECUTED 12f61b: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 12f620: 89 d7 mov %edx,%edi <== NOT EXECUTED 12f622: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 12f624: f7 d1 not %ecx <== NOT EXECUTED 12f626: 49 dec %ecx <== NOT EXECUTED 12f627: 66 89 8d f2 fe ff ff mov %cx,-0x10e(%ebp) <== NOT EXECUTED strcpy( tmp_dirent.d_name, the_jnode->name ); 12f62e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12f631: 52 push %edx <== NOT EXECUTED 12f632: 8d 85 f4 fe ff ff lea -0x10c(%ebp),%eax <== NOT EXECUTED 12f638: 50 push %eax <== NOT EXECUTED 12f639: e8 c6 66 00 00 call 135d04 <== NOT EXECUTED memcpy( 12f63e: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 12f641: 03 bd d4 fe ff ff add -0x12c(%ebp),%edi <== NOT EXECUTED 12f647: b9 43 00 00 00 mov $0x43,%ecx <== NOT EXECUTED 12f64c: 8b b5 c4 fe ff ff mov -0x13c(%ebp),%esi <== NOT EXECUTED 12f652: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED buffer + bytes_transferred, (void *)&tmp_dirent, sizeof( struct dirent ) ); iop->offset = iop->offset + sizeof(struct dirent); 12f654: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 12f657: 81 47 08 0c 01 00 00 addl $0x10c,0x8(%edi) <== NOT EXECUTED bytes_transferred = bytes_transferred + sizeof( struct dirent ); 12f65e: 81 85 d4 fe ff ff 0c addl $0x10c,-0x12c(%ebp) <== NOT EXECUTED 12f665: 01 00 00 <== NOT EXECUTED 12f668: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12f66b: e9 4c ff ff ff jmp 12f5bc <== NOT EXECUTED 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; 12f670: c7 85 d4 fe ff ff 00 movl $0x0,-0x12c(%ebp) <== NOT EXECUTED 12f677: 00 00 00 <== NOT EXECUTED 12f67a: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->next; } /* Success */ return bytes_transferred; } 12f67c: 8b 85 d4 fe ff ff mov -0x12c(%ebp),%eax <== NOT EXECUTED 12f682: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12f685: 5b pop %ebx <== NOT EXECUTED 12f686: 5e pop %esi <== NOT EXECUTED 12f687: 5f pop %edi <== NOT EXECUTED 12f688: c9 leave <== NOT EXECUTED 12f689: c3 ret <== NOT EXECUTED 0012f464 : */ int imfs_dir_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 12f464: 55 push %ebp <== NOT EXECUTED 12f465: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f467: 56 push %esi <== NOT EXECUTED 12f468: 53 push %ebx <== NOT EXECUTED 12f469: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 12f46c: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 12f46f: 8b 1e mov (%esi),%ebx <== NOT EXECUTED /* * You cannot remove a node that still has children */ if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) ) 12f471: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 12f474: 39 43 50 cmp %eax,0x50(%ebx) <== NOT EXECUTED 12f477: 0f 85 8f 00 00 00 jne 12f50c <== NOT EXECUTED /* * You cannot remove the file system root node. */ if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access ) 12f47d: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 12f480: 3b 58 18 cmp 0x18(%eax),%ebx <== NOT EXECUTED 12f483: 0f 84 97 00 00 00 je 12f520 <== NOT EXECUTED /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) 12f489: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED 12f48c: 85 d2 test %edx,%edx <== NOT EXECUTED 12f48e: 0f 85 8c 00 00 00 jne 12f520 <== NOT EXECUTED /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 12f494: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 12f497: 85 c0 test %eax,%eax <== NOT EXECUTED 12f499: 74 13 je 12f4ae <== NOT EXECUTED 12f49b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12f49e: 53 push %ebx <== NOT EXECUTED 12f49f: e8 fc 08 fe ff call 10fda0 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 12f4a4: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED 12f4ab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 12f4ae: 66 ff 4b 34 decw 0x34(%ebx) <== NOT EXECUTED IMFS_update_ctime( the_jnode ); 12f4b2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12f4b5: 6a 00 push $0x0 <== NOT EXECUTED 12f4b7: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 12f4ba: 50 push %eax <== NOT EXECUTED 12f4bb: e8 2c bf fd ff call 10b3ec <== NOT EXECUTED 12f4c0: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 12f4c3: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED /* * The file cannot be open and the link must be less than 1 to free. */ if ( !rtems_libio_is_file_open( the_jnode ) && (the_jnode->st_nlink < 1) ) { 12f4c6: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 12f4c9: e8 96 c0 fd ff call 10b564 <== NOT EXECUTED 12f4ce: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12f4d1: 85 c0 test %eax,%eax <== NOT EXECUTED 12f4d3: 75 2b jne 12f500 <== NOT EXECUTED 12f4d5: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) <== NOT EXECUTED 12f4da: 75 24 jne 12f500 <== NOT EXECUTED /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 12f4dc: 8b 15 ec ba 14 00 mov 0x14baec,%edx <== NOT EXECUTED 12f4e2: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 12f4e5: 3b 06 cmp (%esi),%eax <== NOT EXECUTED 12f4e7: 74 4b je 12f534 <== NOT EXECUTED /* * Free memory associated with a memory file. */ free( the_jnode ); 12f4e9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12f4ec: 53 push %ebx <== NOT EXECUTED 12f4ed: e8 7e be fd ff call 10b370 <== NOT EXECUTED 12f4f2: 31 c0 xor %eax,%eax <== NOT EXECUTED 12f4f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 12f4f7: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12f4fa: 5b pop %ebx <== NOT EXECUTED 12f4fb: 5e pop %esi <== NOT EXECUTED 12f4fc: c9 leave <== NOT EXECUTED 12f4fd: c3 ret <== NOT EXECUTED 12f4fe: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Free memory associated with a memory file. */ free( the_jnode ); 12f500: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 12f502: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12f505: 5b pop %ebx <== NOT EXECUTED 12f506: 5e pop %esi <== NOT EXECUTED 12f507: c9 leave <== NOT EXECUTED 12f508: c3 ret <== NOT EXECUTED 12f509: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * You cannot remove a node that still has children */ if ( ! rtems_chain_is_empty( &the_jnode->info.directory.Entries ) ) rtems_set_errno_and_return_minus_one( ENOTEMPTY ); 12f50c: e8 43 23 00 00 call 131854 <__errno> <== NOT EXECUTED 12f511: c7 00 5a 00 00 00 movl $0x5a,(%eax) <== NOT EXECUTED 12f517: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12f51c: eb e4 jmp 12f502 <== NOT EXECUTED 12f51e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) rtems_set_errno_and_return_minus_one( EBUSY ); 12f520: e8 2f 23 00 00 call 131854 <__errno> <== NOT EXECUTED 12f525: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED 12f52b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12f530: eb d0 jmp 12f502 <== NOT EXECUTED 12f532: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) rtems_filesystem_current.node_access = NULL; 12f534: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 12f53b: eb ac jmp 12f4e9 <== NOT EXECUTED 001243b4 : /* * Initialize useable but dummy databases */ void init_etc_passwd_group(void) { 1243b4: 55 push %ebp <== NOT EXECUTED 1243b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1243b7: 53 push %ebx <== NOT EXECUTED 1243b8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) 1243bb: 80 3d 60 13 16 00 00 cmpb $0x0,0x161360 <== NOT EXECUTED 1243c2: 74 08 je 1243cc <== NOT EXECUTED fprintf( fp, "root:x:0:root\n" "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); } } 1243c4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1243c7: c9 leave <== NOT EXECUTED 1243c8: c3 ret <== NOT EXECUTED 1243c9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) return; etc_passwd_initted = 1; 1243cc: c6 05 60 13 16 00 01 movb $0x1,0x161360 <== NOT EXECUTED mkdir("/etc", 0777); 1243d3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1243d6: 68 ff 01 00 00 push $0x1ff <== NOT EXECUTED 1243db: 68 48 50 14 00 push $0x145048 <== NOT EXECUTED 1243e0: e8 0f 76 fe ff call 10b9f4 <== NOT EXECUTED /* * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { 1243e5: 59 pop %ecx <== NOT EXECUTED 1243e6: 5b pop %ebx <== NOT EXECUTED 1243e7: 68 81 29 14 00 push $0x142981 <== NOT EXECUTED 1243ec: 68 4d 50 14 00 push $0x14504d <== NOT EXECUTED 1243f1: e8 16 dd 00 00 call 13210c <== NOT EXECUTED 1243f6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1243f9: 85 c0 test %eax,%eax <== NOT EXECUTED 1243fb: 74 77 je 124474 <== NOT EXECUTED fclose(fp); 1243fd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124400: 50 push %eax <== NOT EXECUTED 124401: e8 9a d5 00 00 call 1319a0 <== NOT EXECUTED 124406: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { 124409: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12440c: 68 81 29 14 00 push $0x142981 <== NOT EXECUTED 124411: 68 59 50 14 00 push $0x145059 <== NOT EXECUTED 124416: e8 f1 dc 00 00 call 13210c <== NOT EXECUTED 12441b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12441e: 85 c0 test %eax,%eax <== NOT EXECUTED 124420: 74 12 je 124434 <== NOT EXECUTED fclose(fp); 124422: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124425: 50 push %eax <== NOT EXECUTED 124426: e8 75 d5 00 00 call 1319a0 <== NOT EXECUTED 12442b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED fprintf( fp, "root:x:0:root\n" "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); } } 12442e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 124431: c9 leave <== NOT EXECUTED 124432: c3 ret <== NOT EXECUTED 124433: 90 nop <== NOT EXECUTED * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { fclose(fp); } else if ((fp = fopen("/etc/group", "w")) != NULL) { 124434: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124437: 68 3e 25 14 00 push $0x14253e <== NOT EXECUTED 12443c: 68 59 50 14 00 push $0x145059 <== NOT EXECUTED 124441: e8 c6 dc 00 00 call 13210c <== NOT EXECUTED 124446: 89 c3 mov %eax,%ebx <== NOT EXECUTED 124448: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12444b: 85 c0 test %eax,%eax <== NOT EXECUTED 12444d: 0f 84 71 ff ff ff je 1243c4 <== NOT EXECUTED fprintf( fp, "root:x:0:root\n" 124453: 50 push %eax <== NOT EXECUTED 124454: 6a 2a push $0x2a <== NOT EXECUTED 124456: 6a 01 push $0x1 <== NOT EXECUTED 124458: 68 cc 50 14 00 push $0x1450cc <== NOT EXECUTED 12445d: e8 1a e8 00 00 call 132c7c <== NOT EXECUTED "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); 124462: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 124465: e8 36 d5 00 00 call 1319a0 <== NOT EXECUTED 12446a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12446d: e9 52 ff ff ff jmp 1243c4 <== NOT EXECUTED 124472: 66 90 xchg %ax,%ax <== NOT EXECUTED * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { fclose(fp); } else if ((fp = fopen("/etc/passwd", "w")) != NULL) { 124474: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124477: 68 3e 25 14 00 push $0x14253e <== NOT EXECUTED 12447c: 68 4d 50 14 00 push $0x14504d <== NOT EXECUTED 124481: e8 86 dc 00 00 call 13210c <== NOT EXECUTED 124486: 89 c3 mov %eax,%ebx <== NOT EXECUTED 124488: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12448b: 85 c0 test %eax,%eax <== NOT EXECUTED 12448d: 0f 84 76 ff ff ff je 124409 <== NOT EXECUTED fprintf(fp, "root:*:0:0:root::/:/bin/sh\n" 124493: 50 push %eax <== NOT EXECUTED 124494: 6a 66 push $0x66 <== NOT EXECUTED 124496: 6a 01 push $0x1 <== NOT EXECUTED 124498: 68 64 50 14 00 push $0x145064 <== NOT EXECUTED 12449d: e8 da e7 00 00 call 132c7c <== NOT EXECUTED "rtems:*:1:1:RTEMS Application::/:/bin/sh\n" "tty:!:2:2:tty owner::/:/bin/false\n" ); fclose(fp); 1244a2: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1244a5: e8 f6 d4 00 00 call 1319a0 <== NOT EXECUTED 1244aa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1244ad: e9 57 ff ff ff jmp 124409 <== NOT EXECUTED 0010e994 : * This routine will initialize the chain control element that manages the * mount table chain. */ int init_fs_mount_table(void) { 10e994: 55 push %ebp <== NOT EXECUTED 10e995: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e997: c7 05 e0 fd 11 00 e4 movl $0x11fde4,0x11fde0 <== NOT EXECUTED 10e99e: fd 11 00 <== NOT EXECUTED 10e9a1: c7 05 e4 fd 11 00 00 movl $0x0,0x11fde4 <== NOT EXECUTED 10e9a8: 00 00 00 <== NOT EXECUTED 10e9ab: c7 05 e8 fd 11 00 e0 movl $0x11fde0,0x11fde8 <== NOT EXECUTED 10e9b2: fd 11 00 <== NOT EXECUTED rtems_chain_initialize_empty ( &rtems_filesystem_mount_table_control ); return 0; } 10e9b5: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e9b7: c9 leave <== NOT EXECUTED 10e9b8: c3 ret <== NOT EXECUTED 00118ce0 : int ioctl( int fd, ioctl_command_t command, ... ) { 118ce0: 55 push %ebp <== NOT EXECUTED 118ce1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 118ce3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 118ce6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED va_list ap; rtems_status_code rc; rtems_libio_t *iop; void *buffer; rtems_libio_check_fd( fd ); 118ce9: 3b 15 20 84 12 00 cmp 0x128420,%edx <== NOT EXECUTED 118cef: 73 37 jae 118d28 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 118cf1: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 118cf4: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 118cf7: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 118cfa: 03 05 34 db 12 00 add 0x12db34,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 118d00: f6 40 0d 01 testb $0x1,0xd(%eax) <== NOT EXECUTED 118d04: 74 22 je 118d28 <== NOT EXECUTED va_start(ap, command); buffer = va_arg(ap, void *); 118d06: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED /* * Now process the ioctl(). */ if ( !iop->handlers ) 118d09: 8b 50 30 mov 0x30(%eax),%edx <== NOT EXECUTED 118d0c: 85 d2 test %edx,%edx <== NOT EXECUTED 118d0e: 74 18 je 118d28 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->ioctl_h ) 118d10: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 118d13: 85 d2 test %edx,%edx <== NOT EXECUTED 118d15: 74 23 je 118d3a <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); rc = (*iop->handlers->ioctl_h)( iop, command, buffer ); 118d17: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 118d1a: 51 push %ecx <== NOT EXECUTED 118d1b: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 118d1e: 50 push %eax <== NOT EXECUTED 118d1f: ff d2 call *%edx <== NOT EXECUTED 118d21: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return rc; } 118d24: c9 leave <== NOT EXECUTED 118d25: c3 ret <== NOT EXECUTED 118d26: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Now process the ioctl(). */ if ( !iop->handlers ) rtems_set_errno_and_return_minus_one( EBADF ); 118d28: e8 4f 09 00 00 call 11967c <__errno> <== NOT EXECUTED 118d2d: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 118d33: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); rc = (*iop->handlers->ioctl_h)( iop, command, buffer ); return rc; } 118d38: c9 leave <== NOT EXECUTED 118d39: c3 ret <== NOT EXECUTED if ( !iop->handlers ) rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->ioctl_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 118d3a: e8 3d 09 00 00 call 11967c <__errno> <== NOT EXECUTED 118d3f: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 118d45: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED rc = (*iop->handlers->ioctl_h)( iop, command, buffer ); return rc; } 118d4a: c9 leave <== NOT EXECUTED 118d4b: c3 ret <== NOT EXECUTED 001089b4 : /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) { 1089b4: 55 push %ebp <== NOT EXECUTED 1089b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1089b7: 56 push %esi <== NOT EXECUTED 1089b8: 53 push %ebx <== NOT EXECUTED 1089b9: 89 d6 mov %edx,%esi <== NOT EXECUTED 1089bb: 88 c3 mov %al,%bl <== NOT EXECUTED if (tty->termios.c_iflag & ISTRIP) 1089bd: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED 1089c0: f6 c1 20 test $0x20,%cl <== NOT EXECUTED 1089c3: 74 03 je 1089c8 <== NOT EXECUTED c &= 0x7f; 1089c5: 83 e3 7f and $0x7f,%ebx <== NOT EXECUTED if (tty->termios.c_iflag & IUCLC) 1089c8: f6 c5 02 test $0x2,%ch <== NOT EXECUTED 1089cb: 74 10 je 1089dd <== NOT EXECUTED c = tolower (c); 1089cd: 0f b6 d3 movzbl %bl,%edx <== NOT EXECUTED 1089d0: a1 34 d6 11 00 mov 0x11d634,%eax <== NOT EXECUTED 1089d5: f6 04 10 01 testb $0x1,(%eax,%edx,1) <== NOT EXECUTED 1089d9: 75 3d jne 108a18 <== NOT EXECUTED 1089db: 88 d3 mov %dl,%bl <== NOT EXECUTED if (c == '\r') { 1089dd: 80 fb 0d cmp $0xd,%bl <== NOT EXECUTED 1089e0: 0f 84 8a 00 00 00 je 108a70 <== 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)) { 1089e6: 80 fb 0a cmp $0xa,%bl <== NOT EXECUTED 1089e9: 74 35 je 108a20 <== NOT EXECUTED c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 1089eb: 84 db test %bl,%bl <== NOT EXECUTED 1089ed: 75 36 jne 108a25 <== NOT EXECUTED } /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { 1089ef: 8b 56 20 mov 0x20(%esi),%edx <== NOT EXECUTED 1089f2: a1 44 d5 11 00 mov 0x11d544,%eax <== NOT EXECUTED 1089f7: 48 dec %eax <== NOT EXECUTED 1089f8: 39 c2 cmp %eax,%edx <== NOT EXECUTED 1089fa: 7d 78 jge 108a74 <== NOT EXECUTED if (tty->termios.c_lflag & ECHO) 1089fc: f6 46 3c 08 testb $0x8,0x3c(%esi) <== NOT EXECUTED 108a00: 0f 85 86 00 00 00 jne 108a8c <== NOT EXECUTED echo (c, tty); tty->cbuf[tty->ccount++] = c; 108a06: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 108a09: 88 1c 10 mov %bl,(%eax,%edx,1) <== NOT EXECUTED 108a0c: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 108a0f: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED 108a12: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 108a14: 5b pop %ebx <== NOT EXECUTED 108a15: 5e pop %esi <== NOT EXECUTED 108a16: c9 leave <== NOT EXECUTED 108a17: c3 ret <== NOT EXECUTED iproc (unsigned char c, struct rtems_termios_tty *tty) { if (tty->termios.c_iflag & ISTRIP) c &= 0x7f; if (tty->termios.c_iflag & IUCLC) c = tolower (c); 108a18: 83 c2 20 add $0x20,%edx <== NOT EXECUTED 108a1b: eb be jmp 1089db <== NOT EXECUTED 108a1d: 8d 76 00 lea 0x0(%esi),%esi <== 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)) { 108a20: 83 e1 40 and $0x40,%ecx <== NOT EXECUTED 108a23: 75 63 jne 108a88 <== NOT EXECUTED c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 108a25: 8b 46 3c mov 0x3c(%esi),%eax <== NOT EXECUTED 108a28: a8 02 test $0x2,%al <== NOT EXECUTED 108a2a: 74 c3 je 1089ef <== NOT EXECUTED if (c == tty->termios.c_cc[VERASE]) { 108a2c: 38 5e 43 cmp %bl,0x43(%esi) <== NOT EXECUTED 108a2f: 74 6f je 108aa0 <== NOT EXECUTED erase (tty, 0); return 0; } else if (c == tty->termios.c_cc[VKILL]) { 108a31: 38 5e 44 cmp %bl,0x44(%esi) <== NOT EXECUTED 108a34: 0f 84 9e 00 00 00 je 108ad8 <== NOT EXECUTED erase (tty, 1); return 0; } else if (c == tty->termios.c_cc[VEOF]) { 108a3a: 38 5e 45 cmp %bl,0x45(%esi) <== NOT EXECUTED 108a3d: 74 2a je 108a69 <== NOT EXECUTED return 1; } else if (c == '\n') { 108a3f: 80 fb 0a cmp $0xa,%bl <== NOT EXECUTED 108a42: 74 6c je 108ab0 <== 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]) 108a44: 38 5e 4c cmp %bl,0x4c(%esi) <== NOT EXECUTED 108a47: 74 05 je 108a4e <== NOT EXECUTED 108a49: 38 5e 51 cmp %bl,0x51(%esi) <== NOT EXECUTED 108a4c: 75 a1 jne 1089ef <== NOT EXECUTED || (c == tty->termios.c_cc[VEOL2])) { if (tty->termios.c_lflag & ECHO) 108a4e: a8 08 test $0x8,%al <== NOT EXECUTED 108a50: 74 0a je 108a5c <== NOT EXECUTED echo (c, tty); 108a52: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 108a55: 89 f2 mov %esi,%edx <== NOT EXECUTED 108a57: e8 50 fd ff ff call 1087ac <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 108a5c: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 108a5f: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED 108a62: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED 108a65: 40 inc %eax <== NOT EXECUTED 108a66: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED 108a69: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 108a6e: eb a4 jmp 108a14 <== 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) 108a70: 84 c9 test %cl,%cl <== NOT EXECUTED 108a72: 79 08 jns 108a7c <== 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; 108a74: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 108a76: 5b pop %ebx <== NOT EXECUTED 108a77: 5e pop %esi <== NOT EXECUTED 108a78: c9 leave <== NOT EXECUTED 108a79: c3 ret <== NOT EXECUTED 108a7a: 66 90 xchg %ax,%ax <== 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) 108a7c: 80 e5 01 and $0x1,%ch <== NOT EXECUTED 108a7f: 74 a4 je 108a25 <== NOT EXECUTED 108a81: b3 0a mov $0xa,%bl <== NOT EXECUTED 108a83: eb a0 jmp 108a25 <== NOT EXECUTED 108a85: 8d 76 00 lea 0x0(%esi),%esi <== 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; 108a88: b3 0d mov $0xd,%bl <== NOT EXECUTED 108a8a: eb 99 jmp 108a25 <== NOT EXECUTED /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { if (tty->termios.c_lflag & ECHO) echo (c, tty); 108a8c: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 108a8f: 89 f2 mov %esi,%edx <== NOT EXECUTED 108a91: e8 16 fd ff ff call 1087ac <== NOT EXECUTED 108a96: 8b 56 20 mov 0x20(%esi),%edx <== NOT EXECUTED 108a99: e9 68 ff ff ff jmp 108a06 <== NOT EXECUTED 108a9e: 66 90 xchg %ax,%ax <== 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); 108aa0: 31 d2 xor %edx,%edx <== NOT EXECUTED 108aa2: 89 f0 mov %esi,%eax <== NOT EXECUTED 108aa4: e8 63 fd ff ff call 10880c <== NOT EXECUTED 108aa9: 31 c0 xor %eax,%eax <== NOT EXECUTED 108aab: e9 64 ff ff ff jmp 108a14 <== NOT EXECUTED } else if (c == tty->termios.c_cc[VEOF]) { return 1; } else if (c == '\n') { if (tty->termios.c_lflag & (ECHO | ECHONL)) 108ab0: a8 48 test $0x48,%al <== NOT EXECUTED 108ab2: 74 0c je 108ac0 <== NOT EXECUTED echo (c, tty); 108ab4: 89 f2 mov %esi,%edx <== NOT EXECUTED 108ab6: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 108abb: e8 ec fc ff ff call 1087ac <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 108ac0: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 108ac3: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED 108ac6: c6 04 02 0a movb $0xa,(%edx,%eax,1) <== NOT EXECUTED 108aca: 40 inc %eax <== NOT EXECUTED 108acb: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED 108ace: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 108ad3: e9 3c ff ff ff jmp 108a14 <== NOT EXECUTED if (c == tty->termios.c_cc[VERASE]) { erase (tty, 0); return 0; } else if (c == tty->termios.c_cc[VKILL]) { erase (tty, 1); 108ad8: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 108add: 89 f0 mov %esi,%eax <== NOT EXECUTED 108adf: e8 28 fd ff ff call 10880c <== NOT EXECUTED 108ae4: 31 c0 xor %eax,%eax 108ae6: e9 29 ff ff ff jmp 108a14 <== NOT EXECUTED 0011704c : #include int isatty( int fd ) { 11704c: 55 push %ebp <== NOT EXECUTED 11704d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11704f: 83 ec 60 sub $0x60,%esp <== NOT EXECUTED struct stat buf; if (fstat (fd, &buf) < 0) 117052: 8d 45 b4 lea -0x4c(%ebp),%eax <== NOT EXECUTED 117055: 50 push %eax <== NOT EXECUTED 117056: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 117059: e8 3a ff ff ff call 116f98 <== NOT EXECUTED 11705e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 117061: 85 c0 test %eax,%eax <== NOT EXECUTED 117063: 78 17 js 11707c <== NOT EXECUTED 117065: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 117068: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 11706d: 3d 00 20 00 00 cmp $0x2000,%eax <== NOT EXECUTED 117072: 0f 94 c0 sete %al <== NOT EXECUTED 117075: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED if (S_ISCHR (buf.st_mode)) return 1; return 0; } 117078: c9 leave <== NOT EXECUTED 117079: c3 ret <== NOT EXECUTED 11707a: 66 90 xchg %ax,%ax <== NOT EXECUTED int fd ) { struct stat buf; if (fstat (fd, &buf) < 0) 11707c: 31 c0 xor %eax,%eax <== NOT EXECUTED if (S_ISCHR (buf.st_mode)) return 1; return 0; } 11707e: c9 leave <== NOT EXECUTED 11707f: c3 ret <== NOT EXECUTED 0010a430 : int kill( pid_t pid, int sig ) { 10a430: 55 push %ebp <== NOT EXECUTED 10a431: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a433: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return killinfo( pid, sig, NULL ); 10a436: 6a 00 push $0x0 <== NOT EXECUTED 10a438: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a43b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a43e: e8 6d 5f 00 00 call 1103b0 <== NOT EXECUTED } 10a443: c9 leave <== NOT EXECUTED 10a444: c3 ret <== NOT EXECUTED 00121b68 : int killinfo( pid_t pid, int sig, const union sigval *value ) { 121b68: 55 push %ebp <== NOT EXECUTED 121b69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121b6b: 57 push %edi <== NOT EXECUTED 121b6c: 56 push %esi <== NOT EXECUTED 121b6d: 53 push %ebx <== NOT EXECUTED 121b6e: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) 121b71: e8 0a fd ff ff call 121880 <== NOT EXECUTED 121b76: 3b 45 08 cmp 0x8(%ebp),%eax <== NOT EXECUTED 121b79: 0f 85 85 02 00 00 jne 121e04 <== NOT EXECUTED /* * Validate the signal passed. */ if ( !sig ) 121b7f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 121b82: 85 db test %ebx,%ebx <== NOT EXECUTED 121b84: 0f 84 92 02 00 00 je 121e1c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 121b8a: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 121b8d: 49 dec %ecx <== NOT EXECUTED 121b8e: 83 f9 1f cmp $0x1f,%ecx <== NOT EXECUTED 121b91: 0f 87 85 02 00 00 ja 121e1c <== NOT EXECUTED /* * If the signal is being ignored, then we are out of here. */ if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 121b97: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 121b9a: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 121b9d: 83 3c 85 88 e3 12 00 cmpl $0x1,0x12e388(,%eax,4) <== NOT EXECUTED 121ba4: 01 <== NOT EXECUTED 121ba5: 0f 84 e4 00 00 00 je 121c8f <== NOT EXECUTED * 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. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) ) 121bab: 83 7d 0c 08 cmpl $0x8,0xc(%ebp) <== NOT EXECUTED 121baf: 0f 84 e7 00 00 00 je 121c9c <== NOT EXECUTED 121bb5: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) <== NOT EXECUTED 121bb9: 0f 84 dd 00 00 00 je 121c9c <== NOT EXECUTED 121bbf: 83 7d 0c 0b cmpl $0xb,0xc(%ebp) <== NOT EXECUTED 121bc3: 0f 84 d3 00 00 00 je 121c9c <== NOT EXECUTED return pthread_kill( pthread_self(), sig ); mask = signo_to_mask( sig ); 121bc9: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 121bce: d3 e6 shl %cl,%esi <== NOT EXECUTED /* * Build up a siginfo structure */ siginfo = &siginfo_struct; siginfo->si_signo = sig; 121bd0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 121bd3: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED siginfo->si_code = SI_USER; 121bd6: c7 45 ec 01 00 00 00 movl $0x1,-0x14(%ebp) <== NOT EXECUTED if ( !value ) { 121bdd: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 121be0: 85 c9 test %ecx,%ecx <== NOT EXECUTED 121be2: 0f 84 fc 01 00 00 je 121de4 <== NOT EXECUTED siginfo->si_value.sival_int = 0; } else { siginfo->si_value = *value; 121be8: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 121beb: 8b 02 mov (%edx),%eax <== NOT EXECUTED 121bed: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 121bf0: a1 b8 dc 12 00 mov 0x12dcb8,%eax <== NOT EXECUTED 121bf5: 40 inc %eax <== NOT EXECUTED 121bf6: a3 b8 dc 12 00 mov %eax,0x12dcb8 <== NOT EXECUTED /* * 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; 121bfb: 8b 0d 7c dd 12 00 mov 0x12dd7c,%ecx <== NOT EXECUTED api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( _POSIX_signals_Is_interested( api, mask ) ) { 121c01: 8b 81 f8 00 00 00 mov 0xf8(%ecx),%eax <== NOT EXECUTED 121c07: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 121c0d: f7 d0 not %eax <== NOT EXECUTED 121c0f: 85 c6 test %eax,%esi <== NOT EXECUTED 121c11: 75 38 jne 121c4b <== NOT EXECUTED goto process_it; 121c13: bf 20 e5 12 00 mov $0x12e520,%edi <== NOT EXECUTED index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; 121c18: 8b 17 mov (%edi),%edx <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 121c1a: 8d 5f 04 lea 0x4(%edi),%ebx <== NOT EXECUTED !_Chain_Is_tail( the_chain, the_node ) ; 121c1d: 39 da cmp %ebx,%edx <== NOT EXECUTED 121c1f: 75 1d jne 121c3e <== NOT EXECUTED 121c21: e9 da 00 00 00 jmp 121d00 <== NOT EXECUTED 121c26: 66 90 xchg %ax,%ax <== 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)) { 121c28: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 121c2e: f7 d0 not %eax <== NOT EXECUTED 121c30: 85 c6 test %eax,%esi <== NOT EXECUTED 121c32: 75 17 jne 121c4b <== NOT EXECUTED the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; the_node = the_node->next ) { 121c34: 8b 12 mov (%edx),%edx <== NOT EXECUTED index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; 121c36: 39 da cmp %ebx,%edx <== NOT EXECUTED 121c38: 0f 84 c2 00 00 00 je 121d00 <== NOT EXECUTED the_node = the_node->next ) { the_thread = (Thread_Control *)the_node; 121c3e: 89 d1 mov %edx,%ecx <== NOT EXECUTED api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 121c40: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax <== NOT EXECUTED if ((the_thread->Wait.option & mask) || (~api->signals_blocked & mask)) { 121c46: 85 72 30 test %esi,0x30(%edx) <== NOT EXECUTED 121c49: 74 dd je 121c28 <== NOT EXECUTED * evaluate the signals pending. */ process_it: the_thread->do_post_task_switch_extension = true; 121c4b: c6 41 75 01 movb $0x1,0x75(%ecx) <== NOT EXECUTED /* * 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 ) ) { 121c4f: 50 push %eax <== NOT EXECUTED 121c50: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 121c53: 50 push %eax <== NOT EXECUTED 121c54: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 121c57: 51 push %ecx <== NOT EXECUTED 121c58: e8 0f 02 00 00 call 121e6c <_POSIX_signals_Unblock_thread> <== NOT EXECUTED 121c5d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121c60: 84 c0 test %al,%al <== NOT EXECUTED 121c62: 0f 85 8c 00 00 00 jne 121cf4 <== NOT EXECUTED /* * 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 ); 121c68: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 121c6b: 56 push %esi <== NOT EXECUTED 121c6c: e8 d7 01 00 00 call 121e48 <_POSIX_signals_Set_process_signals> <== NOT EXECUTED if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { 121c71: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 121c74: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 121c77: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 121c7e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121c81: 83 bb 80 e3 12 00 02 cmpl $0x2,0x12e380(%ebx) <== NOT EXECUTED 121c88: 74 2e je 121cb8 <== NOT EXECUTED psiginfo->Info = *siginfo; _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); } _Thread_Enable_dispatch(); 121c8a: e8 c9 f4 fe ff call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 121c8f: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 121c91: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 121c94: 5b pop %ebx <== NOT EXECUTED 121c95: 5e pop %esi <== NOT EXECUTED 121c96: 5f pop %edi <== NOT EXECUTED 121c97: c9 leave <== NOT EXECUTED 121c98: c3 ret <== NOT EXECUTED 121c99: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * be directed to the executing thread such as those caused by hardware * faults. */ if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) ) return pthread_kill( pthread_self(), sig ); 121c9c: e8 af 03 00 00 call 122050 <== NOT EXECUTED 121ca1: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 121ca4: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 121ca7: 50 push %eax <== NOT EXECUTED 121ca8: e8 db 02 00 00 call 121f88 <== NOT EXECUTED 121cad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); } _Thread_Enable_dispatch(); return 0; } 121cb0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 121cb3: 5b pop %ebx <== NOT EXECUTED 121cb4: 5e pop %esi <== NOT EXECUTED 121cb5: 5f pop %edi <== NOT EXECUTED 121cb6: c9 leave <== NOT EXECUTED 121cb7: c3 ret <== NOT EXECUTED _POSIX_signals_Set_process_signals( mask ); if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) { psiginfo = (POSIX_signals_Siginfo_node *) 121cb8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 121cbb: 68 00 e5 12 00 push $0x12e500 <== NOT EXECUTED 121cc0: e8 47 df fe ff call 10fc0c <_Chain_Get> <== NOT EXECUTED _Chain_Get( &_POSIX_signals_Inactive_siginfo ); if ( !psiginfo ) { 121cc5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121cc8: 85 c0 test %eax,%eax <== NOT EXECUTED 121cca: 0f 84 61 01 00 00 je 121e31 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EAGAIN ); } psiginfo->Info = *siginfo; 121cd0: 8d 78 08 lea 0x8(%eax),%edi <== NOT EXECUTED 121cd3: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 121cd6: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 121cdb: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node ); 121cdd: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 121ce0: 50 push %eax <== NOT EXECUTED 121ce1: 8d 83 80 e5 12 00 lea 0x12e580(%ebx),%eax <== NOT EXECUTED 121ce7: 50 push %eax <== NOT EXECUTED 121ce8: e8 fb de fe ff call 10fbe8 <_Chain_Append> <== NOT EXECUTED 121ced: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121cf0: eb 98 jmp 121c8a <== NOT EXECUTED 121cf2: 66 90 xchg %ax,%ax <== NOT EXECUTED * 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 ) ) { _Thread_Enable_dispatch(); 121cf4: e8 5f f4 fe ff call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 121cf9: 31 c0 xor %eax,%eax <== NOT EXECUTED 121cfb: eb b3 jmp 121cb0 <== NOT EXECUTED 121cfd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED index++ ) { the_chain = &_POSIX_signals_Wait_queue.Queues.Priority[ index ]; for ( the_node = the_chain->first ; !_Chain_Is_tail( the_chain, the_node ) ; 121d00: 83 c7 0c add $0xc,%edi <== NOT EXECUTED */ /* XXX violation of visibility -- need to define thread queue support */ for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 121d03: 81 ff 50 e5 12 00 cmp $0x12e550,%edi <== NOT EXECUTED 121d09: 0f 85 09 ff ff ff jne 121c18 <== NOT EXECUTED * * + rtems internal threads do not receive signals. */ interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; 121d0f: 0f b6 05 f4 84 12 00 movzbl 0x1284f4,%eax <== NOT EXECUTED 121d16: 8d 78 01 lea 0x1(%eax),%edi <== NOT EXECUTED 121d19: c7 45 d4 02 00 00 00 movl $0x2,-0x2c(%ebp) <== NOT EXECUTED 121d20: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED the_api++ ) { /* * Thie can occur when no one is interested and ITRON is not configured. */ if ( !_Objects_Information_table[ the_api ] ) 121d27: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 121d2a: 8b 04 95 8c dc 12 00 mov 0x12dc8c(,%edx,4),%eax <== NOT EXECUTED 121d31: 85 c0 test %eax,%eax <== NOT EXECUTED 121d33: 0f 84 93 00 00 00 je 121dcc <== NOT EXECUTED continue; the_info = _Objects_Information_table[ the_api ][ 1 ]; 121d39: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED /* * This cannot happen in the current (as of Dec 2007) implementation * of initialization but at some point, the object information * structure for a particular manager may not be installed. */ if ( !the_info ) 121d3c: 85 c0 test %eax,%eax <== NOT EXECUTED 121d3e: 0f 84 88 00 00 00 je 121dcc <== NOT EXECUTED continue; maximum = the_info->maximum; 121d44: 0f b7 50 10 movzwl 0x10(%eax),%edx <== NOT EXECUTED 121d48: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED object_table = the_info->local_table; 121d4b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 121d4e: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED for ( index = 1 ; index <= maximum ; index++ ) { 121d51: 85 d2 test %edx,%edx <== NOT EXECUTED 121d53: 74 77 je 121dcc <== NOT EXECUTED 121d55: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED the_thread = (Thread_Control *) object_table[ index ]; 121d5a: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 121d5d: 8b 14 88 mov (%eax,%ecx,4),%edx <== NOT EXECUTED if ( !the_thread ) 121d60: 85 d2 test %edx,%edx <== NOT EXECUTED 121d62: 74 50 je 121db4 <== NOT EXECUTED /* * If this thread is of lower priority than the interested thread, * go on to the next thread. */ if ( the_thread->current_priority > interested_priority ) 121d64: 8b 5a 14 mov 0x14(%edx),%ebx <== NOT EXECUTED 121d67: 39 fb cmp %edi,%ebx <== NOT EXECUTED 121d69: 77 49 ja 121db4 <== NOT EXECUTED /* * If this thread is not interested, then go on to the next thread. */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 121d6b: 8b 82 f8 00 00 00 mov 0xf8(%edx),%eax <== NOT EXECUTED if ( !api || !_POSIX_signals_Is_interested( api, mask ) ) 121d71: 85 c0 test %eax,%eax <== NOT EXECUTED 121d73: 74 3f je 121db4 <== NOT EXECUTED 121d75: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 121d7b: f7 d0 not %eax <== NOT EXECUTED 121d7d: 85 c6 test %eax,%esi <== NOT EXECUTED 121d7f: 74 33 je 121db4 <== NOT EXECUTED * 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 ) { 121d81: 39 fb cmp %edi,%ebx <== NOT EXECUTED 121d83: 72 17 jb 121d9c <== NOT EXECUTED * 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 ) ) 121d85: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 121d88: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 121d8b: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED 121d8e: 85 c0 test %eax,%eax <== NOT EXECUTED 121d90: 74 22 je 121db4 <== 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 ) ) { 121d92: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 121d95: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 121d98: 85 c0 test %eax,%eax <== NOT EXECUTED 121d9a: 75 54 jne 121df0 <== 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 ) { 121d9c: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED continue; maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 121d9f: 41 inc %ecx <== NOT EXECUTED 121da0: 39 4d d8 cmp %ecx,-0x28(%ebp) <== NOT EXECUTED 121da3: 72 17 jb 121dbc <== NOT EXECUTED 121da5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 121da8: 89 df mov %ebx,%edi <== NOT EXECUTED the_thread = (Thread_Control *) object_table[ index ]; 121daa: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 121dad: 8b 14 88 mov (%eax,%ecx,4),%edx <== NOT EXECUTED if ( !the_thread ) 121db0: 85 d2 test %edx,%edx <== NOT EXECUTED 121db2: 75 b0 jne 121d64 <== 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 ) { 121db4: 89 fb mov %edi,%ebx <== NOT EXECUTED continue; maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 121db6: 41 inc %ecx <== NOT EXECUTED 121db7: 39 4d d8 cmp %ecx,-0x28(%ebp) <== NOT EXECUTED 121dba: 73 ec jae 121da8 <== NOT EXECUTED interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 121dbc: ff 45 d4 incl -0x2c(%ebp) <== NOT EXECUTED interested_thread = NULL; interested_priority = PRIORITY_MAXIMUM + 1; for ( the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; 121dbf: 83 7d d4 05 cmpl $0x5,-0x2c(%ebp) <== NOT EXECUTED 121dc3: 74 0b je 121dd0 <== NOT EXECUTED 121dc5: 89 df mov %ebx,%edi <== NOT EXECUTED 121dc7: e9 5b ff ff ff jmp 121d27 <== NOT EXECUTED continue; maximum = the_info->maximum; object_table = the_info->local_table; for ( index = 1 ; index <= maximum ; index++ ) { 121dcc: 89 fb mov %edi,%ebx <== NOT EXECUTED 121dce: eb ec jmp 121dbc <== NOT EXECUTED interested_priority = the_thread->current_priority; } } } if ( interested_thread ) { 121dd0: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 121dd3: 85 d2 test %edx,%edx <== NOT EXECUTED 121dd5: 0f 84 8d fe ff ff je 121c68 <== NOT EXECUTED 121ddb: 8b 4d e0 mov -0x20(%ebp),%ecx <== NOT EXECUTED 121dde: e9 68 fe ff ff jmp 121c4b <== NOT EXECUTED 121de3: 90 nop <== NOT EXECUTED siginfo = &siginfo_struct; siginfo->si_signo = sig; siginfo->si_code = SI_USER; if ( !value ) { siginfo->si_value.sival_int = 0; 121de4: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED 121deb: e9 00 fe ff ff jmp 121bf0 <== 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 ) 121df0: f7 45 cc 00 00 00 10 testl $0x10000000,-0x34(%ebp) <== NOT EXECUTED 121df7: 75 bb jne 121db4 <== 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 ) { 121df9: a9 00 00 00 10 test $0x10000000,%eax <== NOT EXECUTED 121dfe: 75 9c jne 121d9c <== NOT EXECUTED 121e00: 89 fb mov %edi,%ebx <== NOT EXECUTED 121e02: eb b2 jmp 121db6 <== NOT EXECUTED /* * Only supported for the "calling process" (i.e. this node). */ if ( pid != getpid() ) rtems_set_errno_and_return_minus_one( ESRCH ); 121e04: e8 73 78 ff ff call 11967c <__errno> <== NOT EXECUTED 121e09: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED 121e0f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 121e14: e9 97 fe ff ff jmp 121cb0 <== NOT EXECUTED 121e19: 8d 76 00 lea 0x0(%esi),%esi <== 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 ); 121e1c: e8 5b 78 ff ff call 11967c <__errno> <== NOT EXECUTED 121e21: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 121e27: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 121e2c: e9 7f fe ff ff jmp 121cb0 <== 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 ); 121e31: e8 46 78 ff ff call 11967c <__errno> <== NOT EXECUTED 121e36: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 121e3c: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 121e41: e9 6a fe ff ff jmp 121cb0 <== NOT EXECUTED 00107580 : */ bool libc_create_hook( rtems_tcb *current_task, rtems_tcb *creating_task ) { 107580: 55 push %ebp <== NOT EXECUTED 107581: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107583: 57 push %edi <== NOT EXECUTED 107584: 56 push %esi <== NOT EXECUTED 107585: 53 push %ebx <== NOT EXECUTED 107586: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED ptr = (struct _reent *) calloc(1, sizeof(struct _reent)); #else /* It is OK to allocate from the workspace because these * hooks run with thread dispatching disabled. */ ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent)); 107589: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 10758e: e8 ed 5e 00 00 call 10d480 <_Workspace_Allocate> <== NOT EXECUTED 107593: 89 c6 mov %eax,%esi <== NOT EXECUTED #endif if (ptr) { 107595: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107598: 85 c0 test %eax,%eax <== NOT EXECUTED 10759a: 0f 84 30 02 00 00 je 1077d0 <== NOT EXECUTED _REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */ 1075a0: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 1075a6: 8d 90 ec 02 00 00 lea 0x2ec(%eax),%edx <== NOT EXECUTED 1075ac: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 1075af: 8d 80 48 03 00 00 lea 0x348(%eax),%eax <== NOT EXECUTED 1075b5: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED 1075b8: 8d 86 a4 03 00 00 lea 0x3a4(%esi),%eax <== NOT EXECUTED 1075be: 89 46 0c mov %eax,0xc(%esi) <== NOT EXECUTED 1075c1: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi) <== NOT EXECUTED 1075c8: 8d 7e 14 lea 0x14(%esi),%edi <== NOT EXECUTED 1075cb: 31 c0 xor %eax,%eax <== NOT EXECUTED 1075cd: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED 1075d2: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 1075d4: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 1075d6: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi) <== NOT EXECUTED 1075dd: c7 46 34 f0 8e 11 00 movl $0x118ef0,0x34(%esi) <== NOT EXECUTED 1075e4: c7 46 38 00 00 00 00 movl $0x0,0x38(%esi) <== NOT EXECUTED 1075eb: c7 46 3c 00 00 00 00 movl $0x0,0x3c(%esi) <== NOT EXECUTED 1075f2: c7 46 40 00 00 00 00 movl $0x0,0x40(%esi) <== NOT EXECUTED 1075f9: c7 46 44 00 00 00 00 movl $0x0,0x44(%esi) <== NOT EXECUTED 107600: c7 46 48 00 00 00 00 movl $0x0,0x48(%esi) <== NOT EXECUTED 107607: c7 46 4c 00 00 00 00 movl $0x0,0x4c(%esi) <== NOT EXECUTED 10760e: c7 46 50 00 00 00 00 movl $0x0,0x50(%esi) <== NOT EXECUTED 107615: c7 46 54 00 00 00 00 movl $0x0,0x54(%esi) <== NOT EXECUTED 10761c: c7 46 58 00 00 00 00 movl $0x0,0x58(%esi) <== NOT EXECUTED 107623: c7 46 5c 00 00 00 00 movl $0x0,0x5c(%esi) <== NOT EXECUTED 10762a: c6 46 60 00 movb $0x0,0x60(%esi) <== NOT EXECUTED 10762e: 8d 7e 7c lea 0x7c(%esi),%edi <== NOT EXECUTED 107631: b3 24 mov $0x24,%bl <== NOT EXECUTED 107633: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 107635: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 107637: c7 86 a0 00 00 00 00 movl $0x0,0xa0(%esi) <== NOT EXECUTED 10763e: 00 00 00 <== NOT EXECUTED 107641: c7 86 a4 00 00 00 01 movl $0x1,0xa4(%esi) <== NOT EXECUTED 107648: 00 00 00 <== NOT EXECUTED 10764b: c7 86 a8 00 00 00 00 movl $0x0,0xa8(%esi) <== NOT EXECUTED 107652: 00 00 00 <== NOT EXECUTED 107655: 66 c7 86 ac 00 00 00 movw $0x330e,0xac(%esi) <== NOT EXECUTED 10765c: 0e 33 <== NOT EXECUTED 10765e: 66 c7 86 ae 00 00 00 movw $0xabcd,0xae(%esi) <== NOT EXECUTED 107665: cd ab <== NOT EXECUTED 107667: 66 c7 86 b0 00 00 00 movw $0x1234,0xb0(%esi) <== NOT EXECUTED 10766e: 34 12 <== NOT EXECUTED 107670: 66 c7 86 b2 00 00 00 movw $0xe66d,0xb2(%esi) <== NOT EXECUTED 107677: 6d e6 <== NOT EXECUTED 107679: 66 c7 86 b4 00 00 00 movw $0xdeec,0xb4(%esi) <== NOT EXECUTED 107680: ec de <== NOT EXECUTED 107682: 66 c7 86 b6 00 00 00 movw $0x5,0xb6(%esi) <== NOT EXECUTED 107689: 05 00 <== NOT EXECUTED 10768b: 66 c7 86 b8 00 00 00 movw $0xb,0xb8(%esi) <== NOT EXECUTED 107692: 0b 00 <== NOT EXECUTED 107694: c7 86 bc 00 00 00 00 movl $0x0,0xbc(%esi) <== NOT EXECUTED 10769b: 00 00 00 <== NOT EXECUTED 10769e: c7 86 c0 00 00 00 00 movl $0x0,0xc0(%esi) <== NOT EXECUTED 1076a5: 00 00 00 <== NOT EXECUTED 1076a8: c7 86 c4 00 00 00 00 movl $0x0,0xc4(%esi) <== NOT EXECUTED 1076af: 00 00 00 <== NOT EXECUTED 1076b2: c7 86 c8 00 00 00 00 movl $0x0,0xc8(%esi) <== NOT EXECUTED 1076b9: 00 00 00 <== NOT EXECUTED 1076bc: c7 86 cc 00 00 00 00 movl $0x0,0xcc(%esi) <== NOT EXECUTED 1076c3: 00 00 00 <== NOT EXECUTED 1076c6: c7 86 d0 00 00 00 00 movl $0x0,0xd0(%esi) <== NOT EXECUTED 1076cd: 00 00 00 <== NOT EXECUTED 1076d0: c7 86 f8 00 00 00 00 movl $0x0,0xf8(%esi) <== NOT EXECUTED 1076d7: 00 00 00 <== NOT EXECUTED 1076da: c7 86 fc 00 00 00 00 movl $0x0,0xfc(%esi) <== NOT EXECUTED 1076e1: 00 00 00 <== NOT EXECUTED 1076e4: c7 86 00 01 00 00 00 movl $0x0,0x100(%esi) <== NOT EXECUTED 1076eb: 00 00 00 <== NOT EXECUTED 1076ee: c7 86 04 01 00 00 00 movl $0x0,0x104(%esi) <== NOT EXECUTED 1076f5: 00 00 00 <== NOT EXECUTED 1076f8: c7 86 08 01 00 00 00 movl $0x0,0x108(%esi) <== NOT EXECUTED 1076ff: 00 00 00 <== NOT EXECUTED 107702: c7 86 0c 01 00 00 00 movl $0x0,0x10c(%esi) <== NOT EXECUTED 107709: 00 00 00 <== NOT EXECUTED 10770c: c7 86 10 01 00 00 00 movl $0x0,0x110(%esi) <== NOT EXECUTED 107713: 00 00 00 <== NOT EXECUTED 107716: c7 86 14 01 00 00 00 movl $0x0,0x114(%esi) <== NOT EXECUTED 10771d: 00 00 00 <== NOT EXECUTED 107720: c7 86 18 01 00 00 00 movl $0x0,0x118(%esi) <== NOT EXECUTED 107727: 00 00 00 <== NOT EXECUTED 10772a: c7 86 1c 01 00 00 00 movl $0x0,0x11c(%esi) <== NOT EXECUTED 107731: 00 00 00 <== NOT EXECUTED 107734: c6 86 d4 00 00 00 00 movb $0x0,0xd4(%esi) <== NOT EXECUTED 10773b: c6 86 dc 00 00 00 00 movb $0x0,0xdc(%esi) <== NOT EXECUTED 107742: c7 86 f4 00 00 00 00 movl $0x0,0xf4(%esi) <== NOT EXECUTED 107749: 00 00 00 <== NOT EXECUTED 10774c: c7 86 48 01 00 00 00 movl $0x0,0x148(%esi) <== NOT EXECUTED 107753: 00 00 00 <== NOT EXECUTED 107756: c7 86 4c 01 00 00 00 movl $0x0,0x14c(%esi) <== NOT EXECUTED 10775d: 00 00 00 <== NOT EXECUTED 107760: c7 86 50 01 00 00 00 movl $0x0,0x150(%esi) <== NOT EXECUTED 107767: 00 00 00 <== NOT EXECUTED 10776a: c7 86 54 01 00 00 00 movl $0x0,0x154(%esi) <== NOT EXECUTED 107771: 00 00 00 <== NOT EXECUTED 107774: c7 86 d4 02 00 00 00 movl $0x0,0x2d4(%esi) <== NOT EXECUTED 10777b: 00 00 00 <== NOT EXECUTED 10777e: c7 86 d4 01 00 00 00 movl $0x0,0x1d4(%esi) <== NOT EXECUTED 107785: 00 00 00 <== NOT EXECUTED 107788: c7 86 dc 02 00 00 00 movl $0x0,0x2dc(%esi) <== NOT EXECUTED 10778f: 00 00 00 <== NOT EXECUTED 107792: c7 86 e0 02 00 00 00 movl $0x0,0x2e0(%esi) <== NOT EXECUTED 107799: 00 00 00 <== NOT EXECUTED 10779c: c7 86 e4 02 00 00 00 movl $0x0,0x2e4(%esi) <== NOT EXECUTED 1077a3: 00 00 00 <== NOT EXECUTED 1077a6: c7 86 e8 02 00 00 00 movl $0x0,0x2e8(%esi) <== NOT EXECUTED 1077ad: 00 00 00 <== NOT EXECUTED 1077b0: 66 bb 14 01 mov $0x114,%bx <== NOT EXECUTED 1077b4: 89 d7 mov %edx,%edi <== NOT EXECUTED 1077b6: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 1077b8: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED creating_task->libc_reent = ptr; 1077ba: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1077bd: 89 b0 f0 00 00 00 mov %esi,0xf0(%eax) <== NOT EXECUTED 1077c3: b0 01 mov $0x1,%al <== NOT EXECUTED return true; } else return false; } 1077c5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1077c8: 5b pop %ebx <== NOT EXECUTED 1077c9: 5e pop %esi <== NOT EXECUTED 1077ca: 5f pop %edi <== NOT EXECUTED 1077cb: c9 leave <== NOT EXECUTED 1077cc: c3 ret <== NOT EXECUTED 1077cd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * hooks run with thread dispatching disabled. */ ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent)); #endif if (ptr) { 1077d0: 31 c0 xor %eax,%eax <== NOT EXECUTED creating_task->libc_reent = ptr; return true; } else return false; } 1077d2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1077d5: 5b pop %ebx <== NOT EXECUTED 1077d6: 5e pop %esi <== NOT EXECUTED 1077d7: 5f pop %edi <== NOT EXECUTED 1077d8: c9 leave <== NOT EXECUTED 1077d9: c3 ret <== NOT EXECUTED 001074b4 : rtems_extension libc_delete_hook( rtems_tcb *current_task, rtems_tcb *deleted_task ) { 1074b4: 55 push %ebp <== NOT EXECUTED 1074b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1074b7: 57 push %edi <== NOT EXECUTED 1074b8: 56 push %esi <== NOT EXECUTED 1074b9: 53 push %ebx <== NOT EXECUTED 1074ba: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1074bd: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1074c0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) { 1074c3: 39 f7 cmp %esi,%edi <== NOT EXECUTED 1074c5: 74 55 je 10751c <== NOT EXECUTED ptr = _REENT; } else { ptr = deleted_task->libc_reent; 1074c7: 8b 9e f0 00 00 00 mov 0xf0(%esi),%ebx <== NOT EXECUTED } if (ptr && ptr != &libc_global_reent) { 1074cd: 85 db test %ebx,%ebx <== NOT EXECUTED 1074cf: 74 21 je 1074f2 <== NOT EXECUTED 1074d1: 81 fb 40 d1 11 00 cmp $0x11d140,%ebx <== NOT EXECUTED 1074d7: 74 19 je 1074f2 <== NOT EXECUTED _reclaim_reent(ptr); */ /* * Just in case there are some buffers lying around. */ _fwalk(ptr, newlib_free_buffers); 1074d9: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1074dc: 68 24 75 10 00 push $0x107524 <== NOT EXECUTED 1074e1: 53 push %ebx <== NOT EXECUTED 1074e2: e8 51 9e 00 00 call 111338 <_fwalk> <== NOT EXECUTED #if REENT_MALLOCED free(ptr); #else _Workspace_Free(ptr); 1074e7: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1074ea: e8 79 5f 00 00 call 10d468 <_Workspace_Free> <== NOT EXECUTED 1074ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif } deleted_task->libc_reent = NULL; 1074f2: c7 86 f0 00 00 00 00 movl $0x0,0xf0(%esi) <== NOT EXECUTED 1074f9: 00 00 00 <== NOT EXECUTED /* * Require the switch back to another task to install its own */ if ( current_task == deleted_task ) { 1074fc: 39 f7 cmp %esi,%edi <== NOT EXECUTED 1074fe: 74 08 je 107508 <== NOT EXECUTED _REENT = 0; } } 107500: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107503: 5b pop %ebx <== NOT EXECUTED 107504: 5e pop %esi <== NOT EXECUTED 107505: 5f pop %edi <== NOT EXECUTED 107506: c9 leave <== NOT EXECUTED 107507: c3 ret <== NOT EXECUTED /* * Require the switch back to another task to install its own */ if ( current_task == deleted_task ) { _REENT = 0; 107508: c7 05 40 d6 11 00 00 movl $0x0,0x11d640 <== NOT EXECUTED 10750f: 00 00 00 <== NOT EXECUTED } } 107512: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107515: 5b pop %ebx <== NOT EXECUTED 107516: 5e pop %esi <== NOT EXECUTED 107517: 5f pop %edi <== NOT EXECUTED 107518: c9 leave <== NOT EXECUTED 107519: c3 ret <== NOT EXECUTED 10751a: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) { ptr = _REENT; 10751c: 8b 1d 40 d6 11 00 mov 0x11d640,%ebx <== NOT EXECUTED 107522: eb a9 jmp 1074cd <== NOT EXECUTED 00107498 : struct _reent libc_global_reent __ATTRIBUTE_IMPURE_PTR__ = _REENT_INIT(libc_global_reent); void libc_init(void) { 107498: 55 push %ebp <== NOT EXECUTED 107499: 89 e5 mov %esp,%ebp <== NOT EXECUTED _REENT = &libc_global_reent; 10749b: c7 05 40 d6 11 00 40 movl $0x11d140,0x11d640 <== NOT EXECUTED 1074a2: d1 11 00 <== NOT EXECUTED 1074a5: c7 05 44 f8 11 00 40 movl $0x11d640,0x11f844 <== NOT EXECUTED 1074ac: d6 11 00 <== NOT EXECUTED _Thread_Set_libc_reent (&_REENT); } 1074af: c9 leave <== NOT EXECUTED 1074b0: c3 ret <== NOT EXECUTED 00117168 : extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) { 117168: 55 push %ebp <== NOT EXECUTED 117169: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11716b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED /* * In case RTEMS is already down, don't do this. It could be * dangerous. */ if (!_System_state_Is_up(_System_state_Get())) 11716e: 83 3d 84 f9 11 00 03 cmpl $0x3,0x11f984 <== NOT EXECUTED 117175: 74 05 je 11717c <== NOT EXECUTED */ fclose (stdin); fclose (stdout); fclose (stderr); } 117177: c9 leave <== NOT EXECUTED 117178: c3 ret <== NOT EXECUTED 117179: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * This was already done if the user called exit() directly . _wrapup_reent(0); */ if (_REENT != &libc_global_reent) { 11717c: 81 3d 40 d6 11 00 40 cmpl $0x11d140,0x11d640 <== NOT EXECUTED 117183: d1 11 00 <== NOT EXECUTED 117186: 74 1a je 1171a2 <== NOT EXECUTED _wrapup_reent(&libc_global_reent); 117188: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11718b: 68 40 d1 11 00 push $0x11d140 <== NOT EXECUTED 117190: e8 eb 05 00 00 call 117780 <_wrapup_reent> <== NOT EXECUTED /* 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; 117195: c7 05 40 d6 11 00 40 movl $0x11d140,0x11d640 <== NOT EXECUTED 11719c: d1 11 00 <== NOT EXECUTED 11719f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * * Should this be changed to do *all* file streams? * _fwalk (_REENT, fclose); */ fclose (stdin); 1171a2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1171a5: a1 40 d6 11 00 mov 0x11d640,%eax <== NOT EXECUTED 1171aa: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED 1171ad: e8 1a 9c ff ff call 110dcc <== NOT EXECUTED fclose (stdout); 1171b2: 5a pop %edx <== NOT EXECUTED 1171b3: a1 40 d6 11 00 mov 0x11d640,%eax <== NOT EXECUTED 1171b8: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1171bb: e8 0c 9c ff ff call 110dcc <== NOT EXECUTED fclose (stderr); 1171c0: 58 pop %eax <== NOT EXECUTED 1171c1: a1 40 d6 11 00 mov 0x11d640,%eax <== NOT EXECUTED 1171c6: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 1171c9: e8 fe 9b ff ff call 110dcc <== NOT EXECUTED 1171ce: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1171d1: c9 leave <== NOT EXECUTED 1171d2: c3 ret <== NOT EXECUTED 001248e4 : int link( const char *existing, const char *new ) { 1248e4: 55 push %ebp <== NOT EXECUTED 1248e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1248e7: 57 push %edi <== NOT EXECUTED 1248e8: 56 push %esi <== NOT EXECUTED 1248e9: 53 push %ebx <== NOT EXECUTED 1248ea: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED /* * Get the node we are linking to. */ result = rtems_filesystem_evaluate_path( existing, 0, &existing_loc, true ); 1248ed: 6a 01 push $0x1 <== NOT EXECUTED 1248ef: 8d 5d e0 lea -0x20(%ebp),%ebx <== NOT EXECUTED 1248f2: 53 push %ebx <== NOT EXECUTED 1248f3: 6a 00 push $0x0 <== NOT EXECUTED 1248f5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1248f8: e8 2f 69 fe ff call 10b22c <== NOT EXECUTED if ( result != 0 ) 1248fd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124900: 85 c0 test %eax,%eax <== NOT EXECUTED 124902: 0f 85 dc 00 00 00 jne 1249e4 <== NOT EXECUTED /* * Get the parent of the node we are creating. */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); 124908: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 12490b: 8a 02 mov (%edx),%al <== NOT EXECUTED 12490d: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 12490f: 74 0c je 12491d <== NOT EXECUTED 124911: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 124913: 74 08 je 12491d <== NOT EXECUTED 124915: 84 c0 test %al,%al <== NOT EXECUTED 124917: 0f 85 d7 00 00 00 jne 1249f4 <== NOT EXECUTED 12491d: 8d 7d d0 lea -0x30(%ebp),%edi <== NOT EXECUTED 124920: 89 7d b8 mov %edi,-0x48(%ebp) <== NOT EXECUTED 124923: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED 124928: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 12492b: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 124930: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 124932: b1 01 mov $0x1,%cl <== NOT EXECUTED if ( !parent_loc.ops->evalformake_h ) { 124934: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 124937: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 12493a: 85 d2 test %edx,%edx <== NOT EXECUTED 12493c: 0f 84 80 00 00 00 je 1249c2 <== NOT EXECUTED 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 ); 124942: 56 push %esi <== NOT EXECUTED 124943: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 124946: 50 push %eax <== NOT EXECUTED 124947: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 12494a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 12494d: 01 c8 add %ecx,%eax <== NOT EXECUTED 12494f: 50 push %eax <== NOT EXECUTED 124950: ff d2 call *%edx <== NOT EXECUTED 124952: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( result != 0 ) { 124954: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124957: 85 c0 test %eax,%eax <== NOT EXECUTED 124959: 0f 85 fd 00 00 00 jne 124a5c <== NOT EXECUTED /* * Check to see if the caller is trying to link across file system * boundaries. */ if ( parent_loc.mt_entry != existing_loc.mt_entry ) { 12495f: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 124962: 3b 45 ec cmp -0x14(%ebp),%eax <== NOT EXECUTED 124965: 0f 85 a9 00 00 00 jne 124a14 <== NOT EXECUTED rtems_filesystem_freenode( &existing_loc ); rtems_filesystem_freenode( &parent_loc ); rtems_set_errno_and_return_minus_one( EXDEV ); } if ( !parent_loc.ops->link_h ) { 12496b: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 12496e: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 124971: 85 c0 test %eax,%eax <== NOT EXECUTED 124973: 0f 84 0b 01 00 00 je 124a84 <== NOT EXECUTED 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 ); 124979: 52 push %edx <== NOT EXECUTED 12497a: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 12497d: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 124980: 53 push %ebx <== NOT EXECUTED 124981: ff d0 call *%eax <== NOT EXECUTED 124983: 89 c6 mov %eax,%esi <== NOT EXECUTED rtems_filesystem_freenode( &existing_loc ); 124985: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 124988: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12498b: 85 c0 test %eax,%eax <== NOT EXECUTED 12498d: 74 10 je 12499f <== NOT EXECUTED 12498f: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 124992: 85 c0 test %eax,%eax <== NOT EXECUTED 124994: 74 09 je 12499f <== NOT EXECUTED 124996: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124999: 53 push %ebx <== NOT EXECUTED 12499a: ff d0 call *%eax <== NOT EXECUTED 12499c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 12499f: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 1249a2: 85 c0 test %eax,%eax <== NOT EXECUTED 1249a4: 74 12 je 1249b8 <== NOT EXECUTED 1249a6: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1249a9: 85 c0 test %eax,%eax <== NOT EXECUTED 1249ab: 74 0b je 1249b8 <== NOT EXECUTED 1249ad: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1249b0: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 1249b3: ff d0 call *%eax <== NOT EXECUTED 1249b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 1249b8: 89 f0 mov %esi,%eax <== NOT EXECUTED 1249ba: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1249bd: 5b pop %ebx <== NOT EXECUTED 1249be: 5e pop %esi <== NOT EXECUTED 1249bf: 5f pop %edi <== NOT EXECUTED 1249c0: c9 leave <== NOT EXECUTED 1249c1: c3 ret <== NOT EXECUTED */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); if ( !parent_loc.ops->evalformake_h ) { rtems_filesystem_freenode( &existing_loc ); 1249c2: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1249c5: 85 c0 test %eax,%eax <== NOT EXECUTED 1249c7: 74 10 je 1249d9 <== NOT EXECUTED 1249c9: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1249cc: 85 c0 test %eax,%eax <== NOT EXECUTED 1249ce: 74 09 je 1249d9 <== NOT EXECUTED 1249d0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1249d3: 53 push %ebx <== NOT EXECUTED 1249d4: ff d0 call *%eax <== NOT EXECUTED 1249d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1249d9: e8 76 ce 00 00 call 131854 <__errno> <== NOT EXECUTED 1249de: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1249e4: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED rtems_filesystem_freenode( &existing_loc ); rtems_filesystem_freenode( &parent_loc ); return result; } 1249e9: 89 f0 mov %esi,%eax <== NOT EXECUTED 1249eb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1249ee: 5b pop %ebx <== NOT EXECUTED 1249ef: 5e pop %esi <== NOT EXECUTED 1249f0: 5f pop %edi <== NOT EXECUTED 1249f1: c9 leave <== NOT EXECUTED 1249f2: c3 ret <== NOT EXECUTED 1249f3: 90 nop <== NOT EXECUTED /* * Get the parent of the node we are creating. */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); 1249f4: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 1249f7: 89 45 b8 mov %eax,-0x48(%ebp) <== NOT EXECUTED 1249fa: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED 1249ff: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 124a02: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 124a07: 8b 7d b8 mov -0x48(%ebp),%edi <== NOT EXECUTED 124a0a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 124a0c: e9 23 ff ff ff jmp 124934 <== NOT EXECUTED 124a11: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * Check to see if the caller is trying to link across file system * boundaries. */ if ( parent_loc.mt_entry != existing_loc.mt_entry ) { rtems_filesystem_freenode( &existing_loc ); 124a14: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 124a17: 85 c0 test %eax,%eax <== NOT EXECUTED 124a19: 74 10 je 124a2b <== NOT EXECUTED 124a1b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 124a1e: 85 c0 test %eax,%eax <== NOT EXECUTED 124a20: 74 09 je 124a2b <== NOT EXECUTED 124a22: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124a25: 53 push %ebx <== NOT EXECUTED 124a26: ff d0 call *%eax <== NOT EXECUTED 124a28: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 124a2b: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 124a2e: 85 c0 test %eax,%eax <== NOT EXECUTED 124a30: 74 12 je 124a44 <== NOT EXECUTED 124a32: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 124a35: 85 c0 test %eax,%eax <== NOT EXECUTED 124a37: 74 0b je 124a44 <== NOT EXECUTED 124a39: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124a3c: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 124a3f: ff d0 call *%eax <== NOT EXECUTED 124a41: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EXDEV ); 124a44: e8 0b ce 00 00 call 131854 <__errno> <== NOT EXECUTED 124a49: c7 00 12 00 00 00 movl $0x12,(%eax) <== NOT EXECUTED 124a4f: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 124a54: e9 5f ff ff ff jmp 1249b8 <== NOT EXECUTED 124a59: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 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 ); 124a5c: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 124a5f: 85 c0 test %eax,%eax <== NOT EXECUTED 124a61: 74 10 je 124a73 <== NOT EXECUTED 124a63: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 124a66: 85 c0 test %eax,%eax <== NOT EXECUTED 124a68: 74 09 je 124a73 <== NOT EXECUTED 124a6a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124a6d: 53 push %ebx <== NOT EXECUTED 124a6e: ff d0 call *%eax <== NOT EXECUTED 124a70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( result ); 124a73: e8 dc cd 00 00 call 131854 <__errno> <== NOT EXECUTED 124a78: 89 30 mov %esi,(%eax) <== NOT EXECUTED 124a7a: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 124a7f: e9 34 ff ff ff jmp 1249b8 <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); rtems_set_errno_and_return_minus_one( EXDEV ); } if ( !parent_loc.ops->link_h ) { rtems_filesystem_freenode( &existing_loc ); 124a84: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 124a87: 85 c0 test %eax,%eax <== NOT EXECUTED 124a89: 74 13 je 124a9e <== NOT EXECUTED 124a8b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 124a8e: 85 c0 test %eax,%eax <== NOT EXECUTED 124a90: 74 0c je 124a9e <== NOT EXECUTED 124a92: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124a95: 53 push %ebx <== NOT EXECUTED 124a96: ff d0 call *%eax <== NOT EXECUTED 124a98: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 124a9b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 124a9e: 85 d2 test %edx,%edx <== NOT EXECUTED 124aa0: 74 12 je 124ab4 <== NOT EXECUTED 124aa2: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 124aa5: 85 c0 test %eax,%eax <== NOT EXECUTED 124aa7: 74 0b je 124ab4 <== NOT EXECUTED 124aa9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124aac: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 124aaf: ff d0 call *%eax <== NOT EXECUTED 124ab1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 124ab4: e8 9b cd 00 00 call 131854 <__errno> <== NOT EXECUTED 124ab9: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 124abf: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 124ac4: e9 ef fe ff ff jmp 1249b8 <== NOT EXECUTED 0010a388 : int mode, struct aiocb * const list[], int nent, struct sigevent *sig ) { 10a388: 55 push %ebp <== NOT EXECUTED 10a389: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a38b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a38e: e8 ed 76 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a393: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a399: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a39e: c9 leave <== NOT EXECUTED 10a39f: c3 ret <== NOT EXECUTED 00117080 : off_t lseek( int fd, off_t offset, int whence ) { 117080: 55 push %ebp <== NOT EXECUTED 117081: 89 e5 mov %esp,%ebp <== NOT EXECUTED 117083: 57 push %edi <== NOT EXECUTED 117084: 56 push %esi <== NOT EXECUTED 117085: 53 push %ebx <== NOT EXECUTED 117086: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 117089: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 11708c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11708f: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED rtems_libio_t *iop; off_t old_offset; off_t status; rtems_libio_check_fd( fd ); 117092: 3b 15 00 b1 11 00 cmp 0x11b100,%edx <== NOT EXECUTED 117098: 73 7e jae 117118 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 11709a: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 11709d: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 1170a0: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 1170a7: 03 1d 30 f6 11 00 add 0x11f630,%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 1170ad: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 1170b1: 74 65 je 117118 <== NOT EXECUTED /* * Check as many errors as possible before touching iop->offset. */ if ( !iop->handlers->lseek_h ) 1170b3: 8b 53 30 mov 0x30(%ebx),%edx <== NOT EXECUTED 1170b6: 8b 7a 14 mov 0x14(%edx),%edi <== NOT EXECUTED 1170b9: 85 ff test %edi,%edi <== NOT EXECUTED 1170bb: 74 6d je 11712a <== NOT EXECUTED /* * Now process the lseek(). */ old_offset = iop->offset; 1170bd: 8b 7b 08 mov 0x8(%ebx),%edi <== NOT EXECUTED switch ( whence ) { 1170c0: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED 1170c3: 74 4b je 117110 <== NOT EXECUTED 1170c5: 83 f9 02 cmp $0x2,%ecx <== NOT EXECUTED 1170c8: 74 22 je 1170ec <== NOT EXECUTED 1170ca: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1170cc: 75 2a jne 1170f8 <== NOT EXECUTED case SEEK_SET: iop->offset = offset; 1170ce: 89 73 08 mov %esi,0x8(%ebx) <== NOT EXECUTED /* * At this time, handlers assume iop->offset has the desired * new offset. */ status = (*iop->handlers->lseek_h)( iop, offset, whence ); 1170d1: 50 push %eax <== NOT EXECUTED 1170d2: 51 push %ecx <== NOT EXECUTED 1170d3: 56 push %esi <== NOT EXECUTED 1170d4: 53 push %ebx <== NOT EXECUTED 1170d5: ff 52 14 call *0x14(%edx) <== NOT EXECUTED if ( status == (off_t) -1 ) 1170d8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1170db: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 1170de: 75 03 jne 1170e3 <== NOT EXECUTED iop->offset = old_offset; 1170e0: 89 7b 08 mov %edi,0x8(%ebx) <== NOT EXECUTED /* * So if the operation failed, we have to restore iop->offset. */ return status; } 1170e3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1170e6: 5b pop %ebx <== NOT EXECUTED 1170e7: 5e pop %esi <== NOT EXECUTED 1170e8: 5f pop %edi <== NOT EXECUTED 1170e9: c9 leave <== NOT EXECUTED 1170ea: c3 ret <== NOT EXECUTED 1170eb: 90 nop <== NOT EXECUTED case SEEK_CUR: iop->offset += offset; break; case SEEK_END: iop->offset = iop->size + offset; 1170ec: 89 f0 mov %esi,%eax <== NOT EXECUTED 1170ee: 03 43 04 add 0x4(%ebx),%eax <== NOT EXECUTED 1170f1: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED 1170f4: eb db jmp 1170d1 <== NOT EXECUTED 1170f6: 66 90 xchg %ax,%ax <== NOT EXECUTED break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 1170f8: e8 83 9b ff ff call 110c80 <__errno> <== NOT EXECUTED 1170fd: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 117103: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED /* * So if the operation failed, we have to restore iop->offset. */ return status; } 117108: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11710b: 5b pop %ebx <== NOT EXECUTED 11710c: 5e pop %esi <== NOT EXECUTED 11710d: 5f pop %edi <== NOT EXECUTED 11710e: c9 leave <== NOT EXECUTED 11710f: c3 ret <== NOT EXECUTED case SEEK_SET: iop->offset = offset; break; case SEEK_CUR: iop->offset += offset; 117110: 8d 04 3e lea (%esi,%edi,1),%eax <== NOT EXECUTED 117113: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED 117116: eb b9 jmp 1170d1 <== NOT EXECUTED off_t old_offset; off_t status; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 117118: e8 63 9b ff ff call 110c80 <__errno> <== NOT EXECUTED 11711d: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 117123: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 117128: eb b9 jmp 1170e3 <== 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 ); 11712a: e8 51 9b ff ff call 110c80 <__errno> <== NOT EXECUTED 11712f: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 117135: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 11713a: eb a7 jmp 1170e3 <== NOT EXECUTED 00124bbc : int _STAT_NAME( const char *path, struct stat *buf ) { 124bbc: 55 push %ebp <== NOT EXECUTED 124bbd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124bbf: 57 push %edi <== NOT EXECUTED 124bc0: 56 push %esi <== NOT EXECUTED 124bc1: 53 push %ebx <== NOT EXECUTED 124bc2: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 124bc5: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !buf ) 124bc8: 85 db test %ebx,%ebx <== NOT EXECUTED 124bca: 0f 84 8c 00 00 00 je 124c5c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); status = rtems_filesystem_evaluate_path( path, 0, &loc, _STAT_FOLLOW_LINKS ); 124bd0: 6a 00 push $0x0 <== NOT EXECUTED 124bd2: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 124bd5: 56 push %esi <== NOT EXECUTED 124bd6: 6a 00 push $0x0 <== NOT EXECUTED 124bd8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124bdb: e8 4c 66 fe ff call 10b22c <== NOT EXECUTED if ( status != 0 ) 124be0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124be3: 85 c0 test %eax,%eax <== NOT EXECUTED 124be5: 75 65 jne 124c4c <== NOT EXECUTED return -1; if ( !loc.handlers->fstat_h ){ 124be7: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 124bea: 8b 42 18 mov 0x18(%edx),%eax <== NOT EXECUTED 124bed: 85 c0 test %eax,%eax <== NOT EXECUTED 124bef: 74 39 je 124c2a <== NOT EXECUTED /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( buf, 0, sizeof(struct stat) ); 124bf1: b9 4c 00 00 00 mov $0x4c,%ecx <== NOT EXECUTED 124bf6: 31 c0 xor %eax,%eax <== NOT EXECUTED 124bf8: 89 df mov %ebx,%edi <== NOT EXECUTED 124bfa: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED status = (*loc.handlers->fstat_h)( &loc, buf ); 124bfc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124bff: 53 push %ebx <== NOT EXECUTED 124c00: 56 push %esi <== NOT EXECUTED 124c01: ff 52 18 call *0x18(%edx) <== NOT EXECUTED 124c04: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 124c06: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 124c09: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124c0c: 85 c0 test %eax,%eax <== NOT EXECUTED 124c0e: 74 10 je 124c20 <== NOT EXECUTED 124c10: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 124c13: 85 c0 test %eax,%eax <== NOT EXECUTED 124c15: 74 09 je 124c20 <== NOT EXECUTED 124c17: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124c1a: 56 push %esi <== NOT EXECUTED 124c1b: ff d0 call *%eax <== NOT EXECUTED 124c1d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return status; } 124c20: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124c22: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124c25: 5b pop %ebx <== NOT EXECUTED 124c26: 5e pop %esi <== NOT EXECUTED 124c27: 5f pop %edi <== NOT EXECUTED 124c28: c9 leave <== NOT EXECUTED 124c29: c3 ret <== NOT EXECUTED 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 ); 124c2a: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 124c2d: 85 c0 test %eax,%eax <== NOT EXECUTED 124c2f: 74 10 je 124c41 <== NOT EXECUTED 124c31: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 124c34: 85 c0 test %eax,%eax <== NOT EXECUTED 124c36: 74 09 je 124c41 <== NOT EXECUTED 124c38: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124c3b: 56 push %esi <== NOT EXECUTED 124c3c: ff d0 call *%eax <== NOT EXECUTED 124c3e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 124c41: e8 0e cc 00 00 call 131854 <__errno> <== NOT EXECUTED 124c46: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 124c4c: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED status = (*loc.handlers->fstat_h)( &loc, buf ); rtems_filesystem_freenode( &loc ); return status; } 124c51: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124c53: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124c56: 5b pop %ebx <== NOT EXECUTED 124c57: 5e pop %esi <== NOT EXECUTED 124c58: 5f pop %edi <== NOT EXECUTED 124c59: c9 leave <== NOT EXECUTED 124c5a: c3 ret <== NOT EXECUTED 124c5b: 90 nop <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !buf ) rtems_set_errno_and_return_minus_one( EFAULT ); 124c5c: e8 f3 cb 00 00 call 131854 <__errno> <== NOT EXECUTED 124c61: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 124c67: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED status = (*loc.handlers->fstat_h)( &loc, buf ); rtems_filesystem_freenode( &loc ); return status; } 124c6c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124c6e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124c71: 5b pop %ebx <== NOT EXECUTED 124c72: 5e pop %esi <== NOT EXECUTED 124c73: 5f pop %edi <== NOT EXECUTED 124c74: c9 leave <== NOT EXECUTED 124c75: c3 ret <== NOT EXECUTED 001072b8 : size_t size ) { void *return_this; MSBUMP(malloc_calls, 1); 1072b8: 55 push %ebp <== NOT EXECUTED 1072b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1072bb: 57 push %edi <== NOT EXECUTED 1072bc: 56 push %esi <== NOT EXECUTED 1072bd: 53 push %ebx <== NOT EXECUTED 1072be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1072c1: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1072c4: ff 05 c4 f6 11 00 incl 0x11f6c4 <== NOT EXECUTED /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 1072ca: e8 41 ff ff ff call 107210 <== NOT EXECUTED /* * Validate the parameters */ if ( !size ) 1072cf: 85 ff test %edi,%edi <== NOT EXECUTED 1072d1: 74 5d je 107330 <== NOT EXECUTED return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 1072d3: 83 3d 84 f9 11 00 03 cmpl $0x3,0x11f984 <== NOT EXECUTED 1072da: 74 4b je 107327 <== NOT EXECUTED * Try to give a segment in the current heap if there is not * enough space then try to grow the heap. * If this fails then return a NULL pointer. */ return_this = _Protected_heap_Allocate( &RTEMS_Malloc_Heap, size ); 1072dc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1072df: 57 push %edi <== NOT EXECUTED 1072e0: 68 60 f6 11 00 push $0x11f660 <== NOT EXECUTED 1072e5: e8 d2 4a 00 00 call 10bdbc <_Protected_heap_Allocate> <== NOT EXECUTED 1072ea: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !return_this ) { 1072ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1072ef: 85 c0 test %eax,%eax <== NOT EXECUTED 1072f1: 74 49 je 10733c <== NOT EXECUTED if (rtems_malloc_sbrk_helpers) return_this = (*rtems_malloc_sbrk_helpers->extend)( size ); if ( !return_this ) { errno = ENOMEM; return (void *) 0; 1072f3: 89 c6 mov %eax,%esi <== NOT EXECUTED } /* * If the user wants us to dirty the allocated memory, then do it. */ if ( rtems_malloc_dirty_helper ) 1072f5: a1 0c db 11 00 mov 0x11db0c,%eax <== NOT EXECUTED 1072fa: 85 c0 test %eax,%eax <== NOT EXECUTED 1072fc: 74 0a je 107308 <== NOT EXECUTED (*rtems_malloc_dirty_helper)( return_this, size ); 1072fe: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107301: 57 push %edi <== NOT EXECUTED 107302: 56 push %esi <== NOT EXECUTED 107303: ff d0 call *%eax <== NOT EXECUTED 107305: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 107308: a1 04 db 11 00 mov 0x11db04,%eax <== NOT EXECUTED 10730d: 85 c0 test %eax,%eax <== NOT EXECUTED 10730f: 74 53 je 107364 <== NOT EXECUTED (*rtems_malloc_statistics_helpers->at_malloc)(return_this); 107311: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107314: 56 push %esi <== NOT EXECUTED 107315: ff 50 04 call *0x4(%eax) <== NOT EXECUTED 107318: 89 f3 mov %esi,%ebx <== NOT EXECUTED 10731a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (rtems_malloc_boundary_helpers) (*rtems_malloc_boundary_helpers->at_malloc)(return_this, size); #endif return return_this; } 10731d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10731f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107322: 5b pop %ebx <== NOT EXECUTED 107323: 5e pop %esi <== NOT EXECUTED 107324: 5f pop %edi <== NOT EXECUTED 107325: c9 leave <== NOT EXECUTED 107326: c3 ret <== NOT EXECUTED return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 107327: e8 8c fe ff ff call 1071b8 <== NOT EXECUTED 10732c: 84 c0 test %al,%al <== NOT EXECUTED 10732e: 75 ac jne 1072dc <== NOT EXECUTED /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) (*rtems_malloc_statistics_helpers->at_malloc)(return_this); 107330: 31 db xor %ebx,%ebx <== NOT EXECUTED if (rtems_malloc_boundary_helpers) (*rtems_malloc_boundary_helpers->at_malloc)(return_this, size); #endif return return_this; } 107332: 89 d8 mov %ebx,%eax <== NOT EXECUTED 107334: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107337: 5b pop %ebx <== NOT EXECUTED 107338: 5e pop %esi <== NOT EXECUTED 107339: 5f pop %edi <== NOT EXECUTED 10733a: c9 leave <== NOT EXECUTED 10733b: c3 ret <== NOT EXECUTED */ return_this = _Protected_heap_Allocate( &RTEMS_Malloc_Heap, size ); if ( !return_this ) { if (rtems_malloc_sbrk_helpers) 10733c: a1 08 db 11 00 mov 0x11db08,%eax <== NOT EXECUTED 107341: 85 c0 test %eax,%eax <== NOT EXECUTED 107343: 74 10 je 107355 <== NOT EXECUTED return_this = (*rtems_malloc_sbrk_helpers->extend)( size ); 107345: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107348: 57 push %edi <== NOT EXECUTED 107349: ff 50 04 call *0x4(%eax) <== NOT EXECUTED 10734c: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !return_this ) { 10734e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107351: 85 c0 test %eax,%eax <== NOT EXECUTED 107353: 75 a0 jne 1072f5 <== NOT EXECUTED errno = ENOMEM; 107355: e8 26 99 00 00 call 110c80 <__errno> <== NOT EXECUTED 10735a: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 107360: eb bb jmp 10731d <== NOT EXECUTED 107362: 66 90 xchg %ax,%ax <== NOT EXECUTED (*rtems_malloc_dirty_helper)( return_this, size ); /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 107364: 89 f3 mov %esi,%ebx <== NOT EXECUTED if (rtems_malloc_boundary_helpers) (*rtems_malloc_boundary_helpers->at_malloc)(return_this, size); #endif return return_this; } 107366: 89 d8 mov %ebx,%eax <== NOT EXECUTED 107368: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10736b: 5b pop %ebx <== NOT EXECUTED 10736c: 5e pop %esi <== NOT EXECUTED 10736d: 5f pop %edi <== NOT EXECUTED 10736e: c9 leave <== NOT EXECUTED 10736f: c3 ret <== NOT EXECUTED 001071f8 : } void malloc_deferred_free( void *pointer ) { 1071f8: 55 push %ebp <== NOT EXECUTED 1071f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1071fb: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1071fe: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107201: 68 3c f6 11 00 push $0x11f63c <== NOT EXECUTED 107206: e8 d1 3b 00 00 call 10addc <_Chain_Append> <== NOT EXECUTED 10720b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_chain_append(&RTEMS_Malloc_GC_list, (rtems_chain_node *)pointer); } 10720e: c9 leave <== NOT EXECUTED 10720f: c3 ret <== NOT EXECUTED 001071d4 : void malloc_deferred_frees_initialize(void) { 1071d4: 55 push %ebp <== NOT EXECUTED 1071d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1071d7: c7 05 3c f6 11 00 40 movl $0x11f640,0x11f63c <== NOT EXECUTED 1071de: f6 11 00 <== NOT EXECUTED 1071e1: c7 05 40 f6 11 00 00 movl $0x0,0x11f640 <== NOT EXECUTED 1071e8: 00 00 00 <== NOT EXECUTED 1071eb: c7 05 44 f6 11 00 3c movl $0x11f63c,0x11f644 <== NOT EXECUTED 1071f2: f6 11 00 <== NOT EXECUTED rtems_chain_initialize_empty(&RTEMS_Malloc_GC_list); } 1071f5: c9 leave <== NOT EXECUTED 1071f6: c3 ret <== NOT EXECUTED 00107210 : { rtems_chain_initialize_empty(&RTEMS_Malloc_GC_list); } void malloc_deferred_frees_process(void) { 107210: 55 push %ebp <== NOT EXECUTED 107211: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107213: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107216: eb 0c jmp 107224 <== NOT EXECUTED /* * If some free's have been deferred, then do them now. */ while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL) free(to_be_freed); 107218: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10721b: 50 push %eax <== NOT EXECUTED 10721c: e8 7f fe ff ff call 1070a0 <== NOT EXECUTED 107221: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107224: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107227: 68 3c f6 11 00 push $0x11f63c <== NOT EXECUTED 10722c: e8 cf 3b 00 00 call 10ae00 <_Chain_Get> <== NOT EXECUTED rtems_chain_node *to_be_freed; /* * If some free's have been deferred, then do them now. */ while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL) 107231: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107234: 85 c0 test %eax,%eax <== NOT EXECUTED 107236: 75 e0 jne 107218 <== NOT EXECUTED free(to_be_freed); } 107238: c9 leave <== NOT EXECUTED 107239: c3 ret <== NOT EXECUTED 0010b7fc : /* * Find amount of free heap remaining */ size_t malloc_free_space( void ) { 10b7fc: 55 push %ebp <== NOT EXECUTED 10b7fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b7ff: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Heap_Information info; _Protected_heap_Get_free_information( &RTEMS_Malloc_Heap, &info ); 10b802: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10b805: 50 push %eax <== NOT EXECUTED 10b806: 68 80 1d 16 00 push $0x161d80 <== NOT EXECUTED 10b80b: e8 c8 59 00 00 call 1111d8 <_Protected_heap_Get_free_information> <== NOT EXECUTED 10b810: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED return (size_t) info.largest; } 10b813: c9 leave <== NOT EXECUTED 10b814: c3 ret <== NOT EXECUTED 00124c90 : */ int malloc_info( Heap_Information_block *the_info ) { 124c90: 55 push %ebp <== NOT EXECUTED 124c91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124c93: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124c96: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !the_info ) 124c99: 85 c0 test %eax,%eax <== NOT EXECUTED 124c9b: 74 17 je 124cb4 <== NOT EXECUTED return -1; _Protected_heap_Get_information( &RTEMS_Malloc_Heap, the_info ); 124c9d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124ca0: 50 push %eax <== NOT EXECUTED 124ca1: 68 80 1d 16 00 push $0x161d80 <== NOT EXECUTED 124ca6: e8 71 26 00 00 call 12731c <_Protected_heap_Get_information> <== NOT EXECUTED 124cab: 31 c0 xor %eax,%eax <== NOT EXECUTED 124cad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 124cb0: c9 leave <== NOT EXECUTED 124cb1: c3 ret <== NOT EXECUTED 124cb2: 66 90 xchg %ax,%ax <== NOT EXECUTED int malloc_info( Heap_Information_block *the_info ) { if ( !the_info ) 124cb4: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED return -1; _Protected_heap_Get_information( &RTEMS_Malloc_Heap, the_info ); return 0; } 124cb9: c9 leave <== NOT EXECUTED 124cba: c3 ret <== NOT EXECUTED 001071b8 : #include "malloc_p.h" rtems_chain_control RTEMS_Malloc_GC_list; bool malloc_is_system_state_OK(void) { 1071b8: 55 push %ebp <== NOT EXECUTED 1071b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( _Thread_Dispatch_disable_level > 0 ) 1071bb: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 1071c0: 85 c0 test %eax,%eax <== NOT EXECUTED 1071c2: 75 0c jne 1071d0 <== NOT EXECUTED return false; if ( _ISR_Nest_level > 0 ) 1071c4: a1 58 f8 11 00 mov 0x11f858,%eax <== NOT EXECUTED 1071c9: 85 c0 test %eax,%eax <== NOT EXECUTED 1071cb: 0f 94 c0 sete %al <== NOT EXECUTED return false; return true; } 1071ce: c9 leave <== NOT EXECUTED 1071cf: c3 ret <== NOT EXECUTED rtems_chain_control RTEMS_Malloc_GC_list; bool malloc_is_system_state_OK(void) { if ( _Thread_Dispatch_disable_level > 0 ) 1071d0: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( _ISR_Nest_level > 0 ) return false; return true; } 1071d2: c9 leave <== NOT EXECUTED 1071d3: c3 ret <== NOT EXECUTED 00108758 : #ifdef RTEMS_NEWLIB #include "malloc_p.h" void malloc_report_statistics(void) { 108758: 55 push %ebp <== NOT EXECUTED 108759: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10875b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED malloc_report_statistics_with_plugin( NULL, printk_plugin ); 10875e: 68 98 93 10 00 push $0x109398 <== NOT EXECUTED 108763: 6a 00 push $0x0 <== NOT EXECUTED 108765: e8 06 00 00 00 call 108770 <== NOT EXECUTED 10876a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10876d: c9 leave <== NOT EXECUTED 10876e: c3 ret <== NOT EXECUTED 00124cbc : void malloc_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 124cbc: 55 push %ebp <== NOT EXECUTED 124cbd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124cbf: 57 push %edi <== NOT EXECUTED 124cc0: 56 push %esi <== NOT EXECUTED 124cc1: 53 push %ebx <== NOT EXECUTED 124cc2: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED rtems_malloc_statistics_t *s; uint32_t allocated; s = &rtems_malloc_statistics; allocated = s->lifetime_allocated - s->lifetime_freed; 124cc5: 8b 0d fc 1d 16 00 mov 0x161dfc,%ecx <== NOT EXECUTED 124ccb: 8b 1d 00 1e 16 00 mov 0x161e00,%ebx <== NOT EXECUTED 124cd1: a1 04 1e 16 00 mov 0x161e04,%eax <== NOT EXECUTED 124cd6: 8b 15 08 1e 16 00 mov 0x161e08,%edx <== NOT EXECUTED 124cdc: 89 ce mov %ecx,%esi <== NOT EXECUTED 124cde: 29 c6 sub %eax,%esi <== NOT EXECUTED 124ce0: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED (*print)( 124ce3: 8b 3d f8 1d 16 00 mov 0x161df8,%edi <== NOT EXECUTED 124ce9: 8b 35 e0 1d 16 00 mov 0x161de0,%esi <== NOT EXECUTED 124cef: 0f ac d0 0a shrd $0xa,%edx,%eax <== NOT EXECUTED 124cf3: c1 ea 0a shr $0xa,%edx <== NOT EXECUTED 124cf6: 50 push %eax <== NOT EXECUTED 124cf7: 0f ac d9 0a shrd $0xa,%ebx,%ecx <== NOT EXECUTED 124cfb: c1 eb 0a shr $0xa,%ebx <== NOT EXECUTED 124cfe: 51 push %ecx <== NOT EXECUTED 124cff: 8d 04 bf lea (%edi,%edi,4),%eax <== NOT EXECUTED 124d02: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 124d05: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 124d08: 31 d2 xor %edx,%edx <== NOT EXECUTED 124d0a: f7 f6 div %esi <== NOT EXECUTED 124d0c: 50 push %eax <== NOT EXECUTED 124d0d: c1 ef 0a shr $0xa,%edi <== NOT EXECUTED 124d10: 57 push %edi <== NOT EXECUTED 124d11: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 124d14: 8d 04 92 lea (%edx,%edx,4),%eax <== NOT EXECUTED 124d17: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 124d1a: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 124d1d: 31 d2 xor %edx,%edx <== NOT EXECUTED 124d1f: f7 f6 div %esi <== NOT EXECUTED 124d21: 50 push %eax <== NOT EXECUTED 124d22: c1 6d f0 0a shrl $0xa,-0x10(%ebp) <== NOT EXECUTED 124d26: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 124d29: c1 ee 0a shr $0xa,%esi <== NOT EXECUTED 124d2c: 56 push %esi <== NOT EXECUTED 124d2d: 68 f8 50 14 00 push $0x1450f8 <== NOT EXECUTED 124d32: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124d35: ff 55 0c call *0xc(%ebp) <== NOT EXECUTED s->max_depth / 1024, (s->max_depth * 100) / s->space_available, (uint32_t) (s->lifetime_allocated / 1024), (uint32_t) (s->lifetime_freed / 1024) ); (*print)( 124d38: 83 c4 28 add $0x28,%esp <== NOT EXECUTED 124d3b: ff 35 f4 1d 16 00 pushl 0x161df4 <== NOT EXECUTED 124d41: ff 35 f0 1d 16 00 pushl 0x161df0 <== NOT EXECUTED 124d47: ff 35 ec 1d 16 00 pushl 0x161dec <== NOT EXECUTED 124d4d: ff 35 e4 1d 16 00 pushl 0x161de4 <== NOT EXECUTED 124d53: 68 5c 51 14 00 push $0x14515c <== NOT EXECUTED 124d58: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124d5b: ff 55 0c call *0xc(%ebp) <== NOT EXECUTED 124d5e: 83 c4 20 add $0x20,%esp <== NOT EXECUTED s->malloc_calls, s->free_calls, s->realloc_calls, s->calloc_calls ); } 124d61: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124d64: 5b pop %ebx <== NOT EXECUTED 124d65: 5e pop %esi <== NOT EXECUTED 124d66: 5f pop %edi <== NOT EXECUTED 124d67: c9 leave <== NOT EXECUTED 124d68: c3 ret <== NOT EXECUTED 00108820 : #include "malloc_p.h" #include void malloc_walk(size_t source, size_t printf_enabled) { 108820: 55 push %ebp <== NOT EXECUTED 108821: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108823: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Protected_heap_Walk( &RTEMS_Malloc_Heap, source, printf_enabled ); 108826: 31 c0 xor %eax,%eax <== NOT EXECUTED 108828: 83 7d 0c 00 cmpl $0x0,0xc(%ebp) <== NOT EXECUTED 10882c: 0f 95 c0 setne %al <== NOT EXECUTED 10882f: 50 push %eax <== NOT EXECUTED 108830: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 108833: 68 00 4d 12 00 push $0x124d00 <== NOT EXECUTED 108838: e8 ff 55 00 00 call 10de3c <_Protected_heap_Walk> <== NOT EXECUTED 10883d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 108840: c9 leave <== NOT EXECUTED 108841: c3 ret <== NOT EXECUTED 001297f4 : */ int memfile_blocks_allocated = 0; void *memfile_alloc_block(void) { 1297f4: 55 push %ebp <== NOT EXECUTED 1297f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1297f7: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *memory; memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK); 1297fa: ff 35 90 eb 14 00 pushl 0x14eb90 <== NOT EXECUTED 129800: 6a 01 push $0x1 <== NOT EXECUTED 129802: e8 01 18 fe ff call 10b008 <== NOT EXECUTED if ( memory ) 129807: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12980a: 85 c0 test %eax,%eax <== NOT EXECUTED 12980c: 74 06 je 129814 <== NOT EXECUTED memfile_blocks_allocated++; 12980e: ff 05 58 15 16 00 incl 0x161558 <== NOT EXECUTED return memory; } 129814: c9 leave <== NOT EXECUTED 129815: c3 ret <== NOT EXECUTED 00129c54 : return memfile_check_rmnod( the_jnode ); } int memfile_check_rmnod( IMFS_jnode_t *the_jnode ){ 129c54: 55 push %ebp <== NOT EXECUTED 129c55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129c57: 53 push %ebx <== NOT EXECUTED 129c58: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 129c5b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* * The file cannot be open and the link must be less than 1 to free. */ if ( !rtems_libio_is_file_open( the_jnode ) && (the_jnode->st_nlink < 1) ) { 129c5e: 53 push %ebx <== NOT EXECUTED 129c5f: e8 00 19 fe ff call 10b564 <== NOT EXECUTED 129c64: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129c67: 85 c0 test %eax,%eax <== NOT EXECUTED 129c69: 75 2f jne 129c9a <== NOT EXECUTED 129c6b: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) <== NOT EXECUTED 129c70: 75 28 jne 129c9a <== NOT EXECUTED /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == the_jnode ) 129c72: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED 129c77: 39 58 04 cmp %ebx,0x4(%eax) <== NOT EXECUTED 129c7a: 74 28 je 129ca4 <== NOT EXECUTED rtems_filesystem_current.node_access = NULL; /* * Free memory associated with a memory file. */ if (the_jnode->type != IMFS_LINEAR_FILE) 129c7c: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) <== NOT EXECUTED 129c80: 74 0c je 129c8e <== NOT EXECUTED IMFS_memfile_remove( the_jnode ); 129c82: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129c85: 53 push %ebx <== NOT EXECUTED 129c86: e8 19 fe ff ff call 129aa4 <== NOT EXECUTED 129c8b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free( the_jnode ); 129c8e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129c91: 53 push %ebx <== NOT EXECUTED 129c92: e8 d9 16 fe ff call 10b370 <== NOT EXECUTED 129c97: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 129c9a: 31 c0 xor %eax,%eax <== NOT EXECUTED 129c9c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 129c9f: c9 leave <== NOT EXECUTED 129ca0: c3 ret <== NOT EXECUTED 129ca1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == the_jnode ) rtems_filesystem_current.node_access = NULL; 129ca4: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED 129cab: eb cf jmp 129c7c <== NOT EXECUTED 00129cfc : */ int memfile_close( rtems_libio_t *iop ) { 129cfc: 55 push %ebp <== NOT EXECUTED 129cfd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129cff: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129d02: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 129d05: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED if (iop->flags & LIBIO_FLAGS_APPEND) 129d08: f6 42 0d 02 testb $0x2,0xd(%edx) <== NOT EXECUTED 129d0c: 74 06 je 129d14 <== NOT EXECUTED iop->offset = the_jnode->info.file.size; 129d0e: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 129d11: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED memfile_check_rmnod( the_jnode ); 129d14: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129d17: 51 push %ecx <== NOT EXECUTED 129d18: e8 37 ff ff ff call 129c54 <== NOT EXECUTED return 0; } 129d1d: 31 c0 xor %eax,%eax <== NOT EXECUTED 129d1f: c9 leave <== NOT EXECUTED 129d20: c3 ret <== NOT EXECUTED 001297d8 : */ void memfile_free_block( void *memory ) { 1297d8: 55 push %ebp <== NOT EXECUTED 1297d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1297db: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED #if 0 fprintf(stdout, "(d %p) ", memory ); fflush(stdout); #endif free(memory); 1297de: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1297e1: e8 8a 1b fe ff call 10b370 <== NOT EXECUTED memfile_blocks_allocated--; 1297e6: ff 0d 58 15 16 00 decl 0x161558 <== NOT EXECUTED 1297ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1297ef: c9 leave <== NOT EXECUTED 1297f0: c3 ret <== NOT EXECUTED 00129a28 : void memfile_free_blocks_in_table( block_p **block_table, int entries ) { 129a28: 55 push %ebp <== NOT EXECUTED 129a29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129a2b: 57 push %edi <== NOT EXECUTED 129a2c: 56 push %esi <== NOT EXECUTED 129a2d: 53 push %ebx <== NOT EXECUTED 129a2e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129a31: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED /* * Perform internal consistency checks */ assert( block_table ); 129a34: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129a37: 85 c0 test %eax,%eax <== NOT EXECUTED 129a39: 74 4e je 129a89 <== NOT EXECUTED /* * Now go through all the slots in the table and free the memory. */ b = *block_table; 129a3b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129a3e: 8b 30 mov (%eax),%esi <== NOT EXECUTED for ( i=0 ; i <== NOT EXECUTED 129a44: 31 db xor %ebx,%ebx <== NOT EXECUTED 129a46: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( b[i] ) { 129a48: 8b 04 9e mov (%esi,%ebx,4),%eax <== NOT EXECUTED 129a4b: 85 c0 test %eax,%eax <== NOT EXECUTED 129a4d: 74 13 je 129a62 <== NOT EXECUTED memfile_free_block( b[i] ); 129a4f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129a52: 50 push %eax <== NOT EXECUTED 129a53: e8 80 fd ff ff call 1297d8 <== NOT EXECUTED b[i] = 0; 129a58: c7 04 9e 00 00 00 00 movl $0x0,(%esi,%ebx,4) <== NOT EXECUTED 129a5f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * Now go through all the slots in the table and free the memory. */ b = *block_table; for ( i=0 ; i <== NOT EXECUTED 129a67: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129a6a: 8b 30 mov (%eax),%esi <== NOT EXECUTED /* * Now that all the blocks in the block table are free, we can * free the block table itself. */ memfile_free_block( *block_table ); 129a6c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129a6f: 56 push %esi <== NOT EXECUTED 129a70: e8 63 fd ff ff call 1297d8 <== NOT EXECUTED *block_table = 0; 129a75: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129a78: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 129a7e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 129a81: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 129a84: 5b pop %ebx <== NOT EXECUTED 129a85: 5e pop %esi <== NOT EXECUTED 129a86: 5f pop %edi <== NOT EXECUTED 129a87: c9 leave <== NOT EXECUTED 129a88: c3 ret <== NOT EXECUTED /* * Perform internal consistency checks */ assert( block_table ); 129a89: 68 eb 54 14 00 push $0x1454eb <== NOT EXECUTED 129a8e: 68 1c 56 14 00 push $0x14561c <== NOT EXECUTED 129a93: 68 b1 01 00 00 push $0x1b1 <== NOT EXECUTED 129a98: 68 08 55 14 00 push $0x145508 <== NOT EXECUTED 129a9d: e8 0a 15 fe ff call 10afac <__assert_func> <== NOT EXECUTED 00129ea4 : int memfile_ftruncate( rtems_libio_t *iop, off_t length ) { 129ea4: 55 push %ebp <== NOT EXECUTED 129ea5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129ea7: 53 push %ebx <== NOT EXECUTED 129ea8: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 129eab: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 129eae: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 129eb1: 8b 5a 2c mov 0x2c(%edx),%ebx <== NOT EXECUTED * 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 ) 129eb4: 39 43 50 cmp %eax,0x50(%ebx) <== NOT EXECUTED 129eb7: 7c 27 jl 129ee0 <== 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; 129eb9: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED iop->size = the_jnode->info.file.size; 129ebc: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED IMFS_update_atime( the_jnode ); 129ebf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129ec2: 6a 00 push $0x0 <== NOT EXECUTED 129ec4: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 129ec7: 50 push %eax <== NOT EXECUTED 129ec8: e8 1f 15 fe ff call 10b3ec <== NOT EXECUTED 129ecd: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 129ed0: 89 43 40 mov %eax,0x40(%ebx) <== NOT EXECUTED 129ed3: 31 c0 xor %eax,%eax <== NOT EXECUTED 129ed5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 129ed8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 129edb: c9 leave <== NOT EXECUTED 129edc: c3 ret <== NOT EXECUTED 129edd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * and the new length is greater than the current size. We treat this * as an extend operation. */ if ( length > the_jnode->info.file.size ) return IMFS_memfile_extend( the_jnode, length ); 129ee0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129ee3: 50 push %eax <== NOT EXECUTED 129ee4: 53 push %ebx <== NOT EXECUTED 129ee5: e8 b2 fe ff ff call 129d9c <== NOT EXECUTED 129eea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED iop->size = the_jnode->info.file.size; IMFS_update_atime( the_jnode ); return 0; } 129eed: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 129ef0: c9 leave <== NOT EXECUTED 129ef1: c3 ret <== NOT EXECUTED 001297d0 : int memfile_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 1297d0: 55 push %ebp <== NOT EXECUTED 1297d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; return 0; } 1297d3: 31 c0 xor %eax,%eax <== NOT EXECUTED 1297d5: c9 leave <== NOT EXECUTED 1297d6: c3 ret <== NOT EXECUTED 00129ef4 : off_t memfile_lseek( rtems_libio_t *iop, off_t offset, int whence ) { 129ef4: 55 push %ebp <== NOT EXECUTED 129ef5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129ef7: 56 push %esi <== NOT EXECUTED 129ef8: 53 push %ebx <== NOT EXECUTED 129ef9: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 129efc: 8b 5e 2c mov 0x2c(%esi),%ebx <== NOT EXECUTED if (the_jnode->type == IMFS_LINEAR_FILE) { 129eff: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) <== NOT EXECUTED 129f03: 75 13 jne 129f18 <== NOT EXECUTED if (iop->offset > the_jnode->info.linearfile.size) 129f05: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 129f08: 39 46 08 cmp %eax,0x8(%esi) <== NOT EXECUTED 129f0b: 7f 27 jg 129f34 <== NOT EXECUTED if (IMFS_memfile_extend( the_jnode, iop->offset )) rtems_set_errno_and_return_minus_one( ENOSPC ); iop->size = the_jnode->info.file.size; } return iop->offset; 129f0d: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED } 129f10: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 129f13: 5b pop %ebx <== NOT EXECUTED 129f14: 5e pop %esi <== NOT EXECUTED 129f15: c9 leave <== NOT EXECUTED 129f16: c3 ret <== NOT EXECUTED 129f17: 90 nop <== NOT EXECUTED if (the_jnode->type == IMFS_LINEAR_FILE) { 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 )) 129f18: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129f1b: ff 76 08 pushl 0x8(%esi) <== NOT EXECUTED 129f1e: 53 push %ebx <== NOT EXECUTED 129f1f: e8 78 fe ff ff call 129d9c <== NOT EXECUTED 129f24: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129f27: 85 c0 test %eax,%eax <== NOT EXECUTED 129f29: 75 0e jne 129f39 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); iop->size = the_jnode->info.file.size; 129f2b: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 129f2e: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 129f31: eb da jmp 129f0d <== NOT EXECUTED 129f33: 90 nop <== NOT EXECUTED the_jnode = iop->file_info; if (the_jnode->type == IMFS_LINEAR_FILE) { if (iop->offset > the_jnode->info.linearfile.size) iop->offset = the_jnode->info.linearfile.size; 129f34: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED 129f37: eb d4 jmp 129f0d <== 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 ); 129f39: e8 16 79 00 00 call 131854 <__errno> <== NOT EXECUTED 129f3e: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 129f44: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 129f49: eb c5 jmp 129f10 <== NOT EXECUTED 0012a1bc : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 12a1bc: 55 push %ebp <== NOT EXECUTED 12a1bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12a1bf: 56 push %esi <== NOT EXECUTED 12a1c0: 53 push %ebx <== NOT EXECUTED 12a1c1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 12a1c4: 8b 5e 2c mov 0x2c(%esi),%ebx <== NOT EXECUTED /* * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND)) 12a1c7: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 12a1ca: a9 04 02 00 00 test $0x204,%eax <== NOT EXECUTED 12a1cf: 74 06 je 12a1d7 <== NOT EXECUTED 12a1d1: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) <== NOT EXECUTED 12a1d5: 74 1d je 12a1f4 <== 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) 12a1d7: f6 c4 02 test $0x2,%ah <== NOT EXECUTED 12a1da: 75 10 jne 12a1ec <== NOT EXECUTED iop->offset = the_jnode->info.file.size; iop->size = the_jnode->info.file.size; 12a1dc: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 12a1df: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 12a1e2: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 12a1e4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12a1e7: 5b pop %ebx <== NOT EXECUTED 12a1e8: 5e pop %esi <== NOT EXECUTED 12a1e9: c9 leave <== NOT EXECUTED 12a1ea: c3 ret <== NOT EXECUTED 12a1eb: 90 nop <== NOT EXECUTED if ((count != 0) && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) iop->offset = the_jnode->info.file.size; 12a1ec: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 12a1ef: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED 12a1f2: eb e8 jmp 12a1dc <== NOT EXECUTED /* * Perform 'copy on write' for linear files */ if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND)) && (the_jnode->type == IMFS_LINEAR_FILE)) { uint32_t count = the_jnode->info.linearfile.size; 12a1f4: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED const unsigned char *buffer = the_jnode->info.linearfile.direct; 12a1f7: 8b 53 54 mov 0x54(%ebx),%edx <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; 12a1fa: c7 43 4c 05 00 00 00 movl $0x5,0x4c(%ebx) <== NOT EXECUTED the_jnode->info.file.size = 0; 12a201: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED the_jnode->info.file.indirect = 0; 12a208: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED the_jnode->info.file.doubly_indirect = 0; 12a20f: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED the_jnode->info.file.triply_indirect = 0; 12a216: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED if ((count != 0) 12a21d: 85 c0 test %eax,%eax <== NOT EXECUTED 12a21f: 75 0a jne 12a22b <== NOT EXECUTED 12a221: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED && (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1)) return -1; } if (iop->flags & LIBIO_FLAGS_APPEND) 12a224: f6 c4 02 test $0x2,%ah <== NOT EXECUTED 12a227: 74 b3 je 12a1dc <== NOT EXECUTED 12a229: eb c1 jmp 12a1ec <== 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) 12a22b: 50 push %eax <== NOT EXECUTED 12a22c: 52 push %edx <== NOT EXECUTED 12a22d: 6a 00 push $0x0 <== NOT EXECUTED 12a22f: 53 push %ebx <== NOT EXECUTED 12a230: e8 17 fd ff ff call 129f4c <== NOT EXECUTED 12a235: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12a238: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 12a23b: 75 e4 jne 12a221 <== NOT EXECUTED 12a23d: eb a5 jmp 12a1e4 <== NOT EXECUTED 0012a4a8 : ssize_t memfile_read( rtems_libio_t *iop, void *buffer, size_t count ) { 12a4a8: 55 push %ebp <== NOT EXECUTED 12a4a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12a4ab: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12a4ae: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; return IMFS_memfile_read( the_jnode, iop->offset, buffer, count ); 12a4b1: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 12a4b4: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 12a4b7: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 12a4ba: ff 70 2c pushl 0x2c(%eax) <== NOT EXECUTED 12a4bd: e8 7e fd ff ff call 12a240 <== NOT EXECUTED } 12a4c2: c9 leave <== NOT EXECUTED 12a4c3: c3 ret <== NOT EXECUTED 00129cb0 : */ int memfile_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 129cb0: 55 push %ebp <== NOT EXECUTED 129cb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129cb3: 53 push %ebx <== NOT EXECUTED 129cb4: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 129cb7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129cba: 8b 18 mov (%eax),%ebx <== NOT EXECUTED /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 129cbc: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 129cbf: 85 c0 test %eax,%eax <== NOT EXECUTED 129cc1: 74 13 je 129cd6 <== NOT EXECUTED 129cc3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129cc6: 53 push %ebx <== NOT EXECUTED 129cc7: e8 d4 60 fe ff call 10fda0 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 129ccc: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED 129cd3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 129cd6: 66 ff 4b 34 decw 0x34(%ebx) <== NOT EXECUTED IMFS_update_ctime( the_jnode ); 129cda: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129cdd: 6a 00 push $0x0 <== NOT EXECUTED 129cdf: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 129ce2: 50 push %eax <== NOT EXECUTED 129ce3: e8 04 17 fe ff call 10b3ec <== NOT EXECUTED 129ce8: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 129ceb: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED return memfile_check_rmnod( the_jnode ); 129cee: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 129cf1: e8 5e ff ff ff call 129c54 <== NOT EXECUTED } 129cf6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 129cf9: c9 leave <== NOT EXECUTED 129cfa: c3 ret <== NOT EXECUTED 0012a194 : ssize_t memfile_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 12a194: 55 push %ebp <== NOT EXECUTED 12a195: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12a197: 56 push %esi <== NOT EXECUTED 12a198: 53 push %ebx <== NOT EXECUTED 12a199: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *the_jnode; ssize_t status; the_jnode = iop->file_info; 12a19c: 8b 73 2c mov 0x2c(%ebx),%esi <== NOT EXECUTED status = IMFS_memfile_write( the_jnode, iop->offset, buffer, count ); 12a19f: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 12a1a2: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 12a1a5: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 12a1a8: 56 push %esi <== NOT EXECUTED 12a1a9: e8 9e fd ff ff call 129f4c <== NOT EXECUTED iop->size = the_jnode->info.file.size; 12a1ae: 8b 56 50 mov 0x50(%esi),%edx <== NOT EXECUTED 12a1b1: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED return status; } 12a1b4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12a1b7: 5b pop %ebx <== NOT EXECUTED 12a1b8: 5e pop %esi <== NOT EXECUTED 12a1b9: c9 leave <== NOT EXECUTED 12a1ba: c3 ret <== NOT EXECUTED 0010d880 : */ int miniIMFS_initialize( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 10d880: 55 push %ebp <== NOT EXECUTED 10d881: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d883: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED return IMFS_initialize_support( 10d886: 68 40 f5 11 00 push $0x11f540 <== NOT EXECUTED 10d88b: 68 40 f5 11 00 push $0x11f540 <== NOT EXECUTED 10d890: 68 80 93 11 00 push $0x119380 <== NOT EXECUTED 10d895: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d898: e8 a3 08 00 00 call 10e140 <== NOT EXECUTED temp_mt_entry, &miniIMFS_ops, &rtems_filesystem_null_handlers, /* for memfiles */ &rtems_filesystem_null_handlers /* for directories */ ); } 10d89d: c9 leave <== NOT EXECUTED 10d89e: c3 ret <== NOT EXECUTED 0010e978 : int mkdir( const char *pathname, mode_t mode ) { 10e978: 55 push %ebp <== NOT EXECUTED 10e979: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e97b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e97e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return mknod( pathname, mode | S_IFDIR, 0LL); 10e981: 6a 00 push $0x0 <== NOT EXECUTED 10e983: 6a 00 push $0x0 <== NOT EXECUTED 10e985: 80 cc 40 or $0x40,%ah <== NOT EXECUTED 10e988: 50 push %eax <== NOT EXECUTED 10e989: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10e98c: e8 df 89 ff ff call 107370 <== NOT EXECUTED } 10e991: c9 leave <== NOT EXECUTED 10e992: c3 ret <== NOT EXECUTED 00124d6c : int mkfifo( const char *path, mode_t mode ) { 124d6c: 55 push %ebp <== NOT EXECUTED 124d6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124d6f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124d72: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return mknod( path, mode | S_IFIFO, 0LL ); 124d75: 6a 00 push $0x0 <== NOT EXECUTED 124d77: 6a 00 push $0x0 <== NOT EXECUTED 124d79: 80 cc 10 or $0x10,%ah <== NOT EXECUTED 124d7c: 50 push %eax <== NOT EXECUTED 124d7d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124d80: e8 8b 6c fe ff call 10ba10 <== NOT EXECUTED } 124d85: c9 leave <== NOT EXECUTED 124d86: c3 ret <== NOT EXECUTED 00107370 : int mknod( const char *pathname, mode_t mode, dev_t dev ) { 107370: 55 push %ebp <== NOT EXECUTED 107371: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107373: 57 push %edi <== NOT EXECUTED 107374: 56 push %esi <== NOT EXECUTED 107375: 53 push %ebx <== NOT EXECUTED 107376: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 107379: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10737c: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10737f: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 107382: 89 45 c8 mov %eax,-0x38(%ebp) <== NOT EXECUTED 107385: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED 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) ) ) 107388: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10738b: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 107390: 0f 84 d2 00 00 00 je 107468 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( S_ISFIFO(mode) ) 107396: 3d 00 10 00 00 cmp $0x1000,%eax <== NOT EXECUTED 10739b: 74 30 je 1073cd <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); rtems_filesystem_get_start_loc( pathname, &i, &temp_loc ); 10739d: 8a 03 mov (%ebx),%al <== NOT EXECUTED 10739f: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 1073a1: 74 45 je 1073e8 <== NOT EXECUTED 1073a3: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 1073a5: 74 41 je 1073e8 <== NOT EXECUTED 1073a7: 84 c0 test %al,%al <== NOT EXECUTED 1073a9: 74 3d je 1073e8 <== NOT EXECUTED 1073ab: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 1073ae: 89 45 bc mov %eax,-0x44(%ebp) <== NOT EXECUTED 1073b1: a1 74 d5 11 00 mov 0x11d574,%eax <== NOT EXECUTED 1073b6: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 1073b9: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1073be: 8b 7d bc mov -0x44(%ebp),%edi <== NOT EXECUTED 1073c1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !temp_loc.ops->evalformake_h ) { 1073c3: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 1073c6: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 1073c9: 85 d2 test %edx,%edx <== NOT EXECUTED 1073cb: 75 3e jne 10740b <== NOT EXECUTED if ( result != 0 ) return -1; if ( !temp_loc.ops->mknod_h ) { rtems_filesystem_freenode( &temp_loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); 1073cd: e8 ae 98 00 00 call 110c80 <__errno> <== NOT EXECUTED 1073d2: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1073d8: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc ); rtems_filesystem_freenode( &temp_loc ); return result; } 1073dd: 89 f0 mov %esi,%eax <== NOT EXECUTED 1073df: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1073e2: 5b pop %ebx <== NOT EXECUTED 1073e3: 5e pop %esi <== NOT EXECUTED 1073e4: 5f pop %edi <== NOT EXECUTED 1073e5: c9 leave <== NOT EXECUTED 1073e6: c3 ret <== NOT EXECUTED 1073e7: 90 nop <== NOT EXECUTED 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 ); 1073e8: 8d 55 dc lea -0x24(%ebp),%edx <== NOT EXECUTED 1073eb: 89 55 bc mov %edx,-0x44(%ebp) <== NOT EXECUTED 1073ee: a1 74 d5 11 00 mov 0x11d574,%eax <== NOT EXECUTED 1073f3: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 1073f6: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1073fb: 89 d7 mov %edx,%edi <== NOT EXECUTED 1073fd: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1073ff: b1 01 mov $0x1,%cl <== NOT EXECUTED if ( !temp_loc.ops->evalformake_h ) { 107401: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 107404: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 107407: 85 d2 test %edx,%edx <== NOT EXECUTED 107409: 74 c2 je 1073cd <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*temp_loc.ops->evalformake_h)( 10740b: 50 push %eax <== NOT EXECUTED 10740c: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10740f: 50 push %eax <== NOT EXECUTED 107410: ff 75 bc pushl -0x44(%ebp) <== NOT EXECUTED 107413: 8d 04 0b lea (%ebx,%ecx,1),%eax <== NOT EXECUTED 107416: 50 push %eax <== NOT EXECUTED 107417: ff d2 call *%edx <== NOT EXECUTED &pathname[i], &temp_loc, &name_start ); if ( result != 0 ) 107419: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10741c: 85 c0 test %eax,%eax <== NOT EXECUTED 10741e: 75 b8 jne 1073d8 <== NOT EXECUTED return -1; if ( !temp_loc.ops->mknod_h ) { 107420: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 107423: 8b 50 14 mov 0x14(%eax),%edx <== NOT EXECUTED 107426: 85 d2 test %edx,%edx <== NOT EXECUTED 107428: 74 53 je 10747d <== NOT EXECUTED 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 ); 10742a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10742d: ff 75 bc pushl -0x44(%ebp) <== NOT EXECUTED 107430: ff 75 cc pushl -0x34(%ebp) <== NOT EXECUTED 107433: ff 75 c8 pushl -0x38(%ebp) <== NOT EXECUTED 107436: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 107439: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10743c: ff d2 call *%edx <== NOT EXECUTED 10743e: 89 c6 mov %eax,%esi <== NOT EXECUTED rtems_filesystem_freenode( &temp_loc ); 107440: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 107443: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 107446: 85 c0 test %eax,%eax <== NOT EXECUTED 107448: 74 93 je 1073dd <== NOT EXECUTED 10744a: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10744d: 85 c0 test %eax,%eax <== NOT EXECUTED 10744f: 74 8c je 1073dd <== NOT EXECUTED 107451: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107454: ff 75 bc pushl -0x44(%ebp) <== NOT EXECUTED 107457: ff d0 call *%eax <== NOT EXECUTED 107459: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 10745c: 89 f0 mov %esi,%eax <== NOT EXECUTED 10745e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107461: 5b pop %ebx <== NOT EXECUTED 107462: 5e pop %esi <== NOT EXECUTED 107463: 5f pop %edi <== NOT EXECUTED 107464: c9 leave <== NOT EXECUTED 107465: c3 ret <== NOT EXECUTED 107466: 66 90 xchg %ax,%ax <== NOT EXECUTED 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 ); 107468: e8 13 98 00 00 call 110c80 <__errno> <== NOT EXECUTED 10746d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 107473: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 107478: e9 60 ff ff ff jmp 1073dd <== NOT EXECUTED ); if ( result != 0 ) return -1; if ( !temp_loc.ops->mknod_h ) { rtems_filesystem_freenode( &temp_loc ); 10747d: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 107480: 85 c0 test %eax,%eax <== NOT EXECUTED 107482: 0f 84 45 ff ff ff je 1073cd <== NOT EXECUTED 107488: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10748b: ff 75 bc pushl -0x44(%ebp) <== NOT EXECUTED 10748e: ff d0 call *%eax <== NOT EXECUTED 107490: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107493: e9 35 ff ff ff jmp 1073cd <== NOT EXECUTED 0010e9bc : const rtems_filesystem_operations_table *fs_ops, rtems_filesystem_options_t options, const char *device, const char *mount_point ) { 10e9bc: 55 push %ebp <== NOT EXECUTED 10e9bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e9bf: 57 push %edi <== NOT EXECUTED 10e9c0: 56 push %esi <== NOT EXECUTED 10e9c1: 53 push %ebx <== NOT EXECUTED 10e9c2: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10e9c5: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED /* * Is there a file system operations table? */ if ( fs_ops == NULL ) { 10e9c8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e9cb: 85 c0 test %eax,%eax <== NOT EXECUTED 10e9cd: 0f 84 75 02 00 00 je 10ec48 <== NOT EXECUTED /* * Are the file system options valid? */ if ( options != RTEMS_FILESYSTEM_READ_ONLY && 10e9d3: 83 fe 01 cmp $0x1,%esi <== NOT EXECUTED 10e9d6: 0f 87 6c 02 00 00 ja 10ec48 <== NOT EXECUTED errno = EINVAL; return -1; } /* Do they support being mounted at all ? */ if ( !fs_ops->fsmount_me_h ) { 10e9dc: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e9df: 8b 78 24 mov 0x24(%eax),%edi <== NOT EXECUTED 10e9e2: 85 ff test %edi,%edi <== NOT EXECUTED 10e9e4: 0f 84 cb 00 00 00 je 10eab5 <== NOT EXECUTED /* * Allocate a mount table entry */ size = sizeof(rtems_filesystem_mount_table_entry_t); if ( device ) 10e9ea: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 10e9ed: 85 db test %ebx,%ebx <== NOT EXECUTED 10e9ef: 0f 84 ef 00 00 00 je 10eae4 <== NOT EXECUTED size += strlen( device ) + 1; 10e9f5: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e9f7: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 10e9fc: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 10e9ff: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 10ea01: f7 d1 not %ecx <== NOT EXECUTED 10ea03: 8d 41 64 lea 0x64(%ecx),%eax <== NOT EXECUTED temp_mt_entry = malloc( size ); 10ea06: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ea09: 50 push %eax <== NOT EXECUTED 10ea0a: e8 a9 88 ff ff call 1072b8 <== NOT EXECUTED 10ea0f: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10ea11: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED if ( !temp_mt_entry ) { 10ea14: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ea17: 85 c0 test %eax,%eax <== NOT EXECUTED 10ea19: 0f 84 3e 02 00 00 je 10ec5d <== NOT EXECUTED errno = ENOMEM; return -1; } temp_mt_entry->mt_fs_root.mt_entry = temp_mt_entry; 10ea1f: 89 43 24 mov %eax,0x24(%ebx) <== NOT EXECUTED temp_mt_entry->options = options; 10ea22: 89 70 28 mov %esi,0x28(%eax) <== NOT EXECUTED if ( device ) { 10ea25: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10ea28: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ea2a: 0f 84 3c 01 00 00 je 10eb6c <== NOT EXECUTED temp_mt_entry->dev = 10ea30: 8d 40 64 lea 0x64(%eax),%eax <== NOT EXECUTED 10ea33: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED (char *)temp_mt_entry + sizeof( rtems_filesystem_mount_table_entry_t ); strcpy( temp_mt_entry->dev, device ); 10ea36: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ea39: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10ea3c: 50 push %eax <== NOT EXECUTED 10ea3d: e8 4a 33 00 00 call 111d8c <== NOT EXECUTED 10ea42: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * The mount_point should be a directory with read/write/execute * permissions in the existing tree. */ if ( mount_point ) { 10ea45: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 10ea48: 85 d2 test %edx,%edx <== NOT EXECUTED 10ea4a: 0f 84 a0 00 00 00 je 10eaf0 <== NOT EXECUTED if ( rtems_filesystem_evaluate_path( 10ea50: 6a 01 push $0x1 <== NOT EXECUTED 10ea52: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 10ea55: 56 push %esi <== NOT EXECUTED 10ea56: 6a 07 push $0x7 <== NOT EXECUTED 10ea58: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10ea5b: e8 fc 84 ff ff call 106f5c <== NOT EXECUTED 10ea60: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ea63: 40 inc %eax <== NOT EXECUTED 10ea64: 74 62 je 10eac8 <== NOT EXECUTED /* * Test for node_type_h */ if (!loc.ops->node_type_h) { 10ea66: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10ea69: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 10ea6c: 85 c0 test %eax,%eax <== NOT EXECUTED 10ea6e: 0f 84 9c 01 00 00 je 10ec10 <== NOT EXECUTED /* * Test to see if it is a directory */ if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 10ea74: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ea77: 56 push %esi <== NOT EXECUTED 10ea78: ff d0 call *%eax <== NOT EXECUTED 10ea7a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ea7d: 48 dec %eax <== NOT EXECUTED 10ea7e: 0f 84 f4 00 00 00 je 10eb78 <== NOT EXECUTED errno = ENOTDIR; 10ea84: e8 f7 21 00 00 call 110c80 <__errno> <== NOT EXECUTED 10ea89: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED return 0; cleanup_and_bail: free( temp_mt_entry ); 10ea8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ea92: 53 push %ebx <== NOT EXECUTED 10ea93: e8 08 86 ff ff call 1070a0 <== NOT EXECUTED 10ea98: 89 f7 mov %esi,%edi <== NOT EXECUTED 10ea9a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); 10ea9d: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED 10eaa0: 85 c0 test %eax,%eax <== NOT EXECUTED 10eaa2: 0f 85 78 01 00 00 jne 10ec20 <== NOT EXECUTED 10eaa8: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED return -1; } 10eaad: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10eab0: 5b pop %ebx <== NOT EXECUTED 10eab1: 5e pop %esi <== NOT EXECUTED 10eab2: 5f pop %edi <== NOT EXECUTED 10eab3: c9 leave <== NOT EXECUTED 10eab4: c3 ret <== NOT EXECUTED return -1; } /* Do they support being mounted at all ? */ if ( !fs_ops->fsmount_me_h ) { errno = ENOTSUP; 10eab5: e8 c6 21 00 00 call 110c80 <__errno> <== NOT EXECUTED 10eaba: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10eac0: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 10eac7: 90 nop <== NOT EXECUTED return 0; cleanup_and_bail: free( temp_mt_entry ); 10eac8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eacb: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10eace: e8 cd 85 ff ff call 1070a0 <== NOT EXECUTED 10ead3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ead8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; } 10eadb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10eade: 5b pop %ebx <== NOT EXECUTED 10eadf: 5e pop %esi <== NOT EXECUTED 10eae0: 5f pop %edi <== NOT EXECUTED 10eae1: c9 leave <== NOT EXECUTED 10eae2: c3 ret <== NOT EXECUTED 10eae3: 90 nop <== NOT EXECUTED /* * Allocate a mount table entry */ size = sizeof(rtems_filesystem_mount_table_entry_t); if ( device ) 10eae4: b8 64 00 00 00 mov $0x64,%eax <== NOT EXECUTED 10eae9: e9 18 ff ff ff jmp 10ea06 <== NOT EXECUTED 10eaee: 66 90 xchg %ax,%ax <== 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; 10eaf0: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED temp_mt_entry->mt_fs_root.handlers = NULL; 10eaf7: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED temp_mt_entry->mt_fs_root.ops = NULL; 10eafe: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.node_access = NULL; 10eb05: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.handlers = NULL; 10eb0c: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.ops = NULL; 10eb13: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.mt_entry = NULL; 10eb1a: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) <== NOT EXECUTED 10eb21: 31 ff xor %edi,%edi <== NOT EXECUTED } if ( fs_ops->fsmount_me_h( temp_mt_entry ) ) { 10eb23: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eb26: 53 push %ebx <== NOT EXECUTED 10eb27: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10eb2a: ff 52 24 call *0x24(%edx) <== NOT EXECUTED 10eb2d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eb30: 85 c0 test %eax,%eax <== NOT EXECUTED 10eb32: 0f 84 a0 00 00 00 je 10ebd8 <== NOT EXECUTED /* try to undo the mount operation */ if ( loc.ops->unmount_h ) { 10eb38: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10eb3b: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 10eb3e: 85 c0 test %eax,%eax <== NOT EXECUTED 10eb40: 74 09 je 10eb4b <== NOT EXECUTED loc.ops->unmount_h( temp_mt_entry ); 10eb42: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eb45: 53 push %ebx <== NOT EXECUTED 10eb46: ff d0 call *%eax <== NOT EXECUTED 10eb48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; cleanup_and_bail: free( temp_mt_entry ); 10eb4b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eb4e: 53 push %ebx <== NOT EXECUTED 10eb4f: e8 4c 85 ff ff call 1070a0 <== NOT EXECUTED if ( loc_to_free ) 10eb54: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eb57: 85 ff test %edi,%edi <== NOT EXECUTED 10eb59: 0f 85 3e ff ff ff jne 10ea9d <== NOT EXECUTED rtems_filesystem_freenode( loc_to_free ); 10eb5f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10eb64: e9 44 ff ff ff jmp 10eaad <== NOT EXECUTED 10eb69: 8d 76 00 lea 0x0(%esi),%esi <== 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; 10eb6c: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) <== NOT EXECUTED 10eb73: e9 cd fe ff ff jmp 10ea45 <== NOT EXECUTED /* * For each mount table entry */ for ( the_node = rtems_filesystem_mount_table_control.first; 10eb78: a1 e0 fd 11 00 mov 0x11fde0,%eax <== NOT EXECUTED !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); 10eb7d: 3d e4 fd 11 00 cmp $0x11fde4,%eax <== NOT EXECUTED 10eb82: 0f 84 b6 00 00 00 je 10ec3e <== NOT EXECUTED the_node = the_node->next ) { the_mount_entry = (rtems_filesystem_mount_table_entry_t *) the_node; if ( the_mount_entry->mt_fs_root.node_access == loc->node_access ) 10eb88: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10eb8b: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED 10eb8e: 75 09 jne 10eb99 <== NOT EXECUTED 10eb90: eb 6e jmp 10ec00 <== NOT EXECUTED 10eb92: 66 90 xchg %ax,%ax <== NOT EXECUTED 10eb94: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED 10eb97: 74 67 je 10ec00 <== NOT EXECUTED * For each mount table entry */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { 10eb99: 8b 00 mov (%eax),%eax <== NOT EXECUTED /* * For each mount table entry */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); 10eb9b: 3d e4 fd 11 00 cmp $0x11fde4,%eax <== NOT EXECUTED 10eba0: 75 f2 jne 10eb94 <== NOT EXECUTED * may have been allocated in loc should not be sent to freenode * until the system is unmounted. It may be needed to correctly * traverse the tree. */ temp_mt_entry->mt_point_node.node_access = loc.node_access; 10eba2: 89 53 08 mov %edx,0x8(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.handlers = loc.handlers; 10eba5: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10eba8: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.ops = loc.ops; 10ebab: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10ebae: 89 53 10 mov %edx,0x10(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry; 10ebb1: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10ebb4: 89 43 14 mov %eax,0x14(%ebx) <== 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 ){ 10ebb7: 8b 42 20 mov 0x20(%edx),%eax <== NOT EXECUTED 10ebba: 85 c0 test %eax,%eax <== NOT EXECUTED 10ebbc: 74 52 je 10ec10 <== NOT EXECUTED errno = ENOTSUP; goto cleanup_and_bail; } if ( loc.ops->mount_h( temp_mt_entry ) ) { 10ebbe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ebc1: 53 push %ebx <== NOT EXECUTED 10ebc2: ff d0 call *%eax <== NOT EXECUTED 10ebc4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ebc7: 85 c0 test %eax,%eax <== NOT EXECUTED 10ebc9: 0f 85 c0 fe ff ff jne 10ea8f <== NOT EXECUTED goto cleanup_and_bail; 10ebcf: 89 f7 mov %esi,%edi <== NOT EXECUTED 10ebd1: e9 4d ff ff ff jmp 10eb23 <== NOT EXECUTED 10ebd6: 66 90 xchg %ax,%ax <== NOT EXECUTED 10ebd8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ebdb: 53 push %ebx <== NOT EXECUTED 10ebdc: 68 e0 fd 11 00 push $0x11fde0 <== NOT EXECUTED 10ebe1: e8 f6 c1 ff ff call 10addc <_Chain_Append> <== NOT EXECUTED */ rtems_chain_append( &rtems_filesystem_mount_table_control, &temp_mt_entry->Node ); if ( mt_entry ) 10ebe6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ebe9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ebec: 85 c0 test %eax,%eax <== NOT EXECUTED 10ebee: 74 05 je 10ebf5 <== NOT EXECUTED *mt_entry = temp_mt_entry; 10ebf0: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10ebf3: 89 1f mov %ebx,(%edi) <== NOT EXECUTED 10ebf5: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; } 10ebf7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ebfa: 5b pop %ebx <== NOT EXECUTED 10ebfb: 5e pop %esi <== NOT EXECUTED 10ebfc: 5f pop %edi <== NOT EXECUTED 10ebfd: c9 leave <== NOT EXECUTED 10ebfe: c3 ret <== NOT EXECUTED 10ebff: 90 nop <== NOT EXECUTED /* * You can only mount one file system onto a single mount point. */ if ( Is_node_fs_root( &loc ) ){ errno = EBUSY; 10ec00: e8 7b 20 00 00 call 110c80 <__errno> <== NOT EXECUTED 10ec05: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED 10ec0b: e9 7f fe ff ff jmp 10ea8f <== 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; 10ec10: e8 6b 20 00 00 call 110c80 <__errno> <== NOT EXECUTED 10ec15: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10ec1b: e9 6f fe ff ff jmp 10ea8f <== NOT EXECUTED cleanup_and_bail: free( temp_mt_entry ); if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); 10ec20: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10ec23: 85 c0 test %eax,%eax <== NOT EXECUTED 10ec25: 0f 84 7d fe ff ff je 10eaa8 <== NOT EXECUTED 10ec2b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ec2e: 57 push %edi <== NOT EXECUTED 10ec2f: ff d0 call *%eax <== NOT EXECUTED 10ec31: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ec36: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ec39: e9 9d fe ff ff jmp 10eadb <== NOT EXECUTED 10ec3e: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10ec41: e9 5c ff ff ff jmp 10eba2 <== NOT EXECUTED 10ec46: 66 90 xchg %ax,%ax <== NOT EXECUTED * Are the file system options valid? */ if ( options != RTEMS_FILESYSTEM_READ_ONLY && options != RTEMS_FILESYSTEM_READ_WRITE ) { errno = EINVAL; 10ec48: e8 33 20 00 00 call 110c80 <__errno> <== NOT EXECUTED 10ec4d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10ec53: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ec58: e9 7e fe ff ff jmp 10eadb <== NOT EXECUTED if ( device ) size += strlen( device ) + 1; temp_mt_entry = malloc( size ); if ( !temp_mt_entry ) { errno = ENOMEM; 10ec5d: e8 1e 20 00 00 call 110c80 <__errno> <== NOT EXECUTED 10ec62: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10ec68: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ec6d: e9 69 fe ff ff jmp 10eadb <== NOT EXECUTED 0010a3a0 : * As of gcc 4.2.2, the gcc SPARC backend doesn't appear to have a * way to call this for RTEMS anymore but it doesn't hurt to leave it. */ int mprotect(const void *addr, size_t len, int prot) { 10a3a0: 55 push %ebp <== NOT EXECUTED 10a3a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 10a3a3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a3a5: c9 leave <== NOT EXECUTED 10a3a6: c3 ret <== NOT EXECUTED 0010d850 : */ int mq_close( mqd_t mqdes ) { 10d850: 55 push %ebp <== NOT EXECUTED 10d851: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d853: 53 push %ebx <== NOT EXECUTED 10d854: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 10d857: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10d85a: 50 push %eax <== NOT EXECUTED 10d85b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d85e: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10d863: e8 88 35 00 00 call 110df0 <_Objects_Get> <== NOT EXECUTED 10d868: 89 c3 mov %eax,%ebx <== NOT EXECUTED 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 ); if ( location == OBJECTS_LOCAL ) { 10d86a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d86d: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10d870: 85 c0 test %eax,%eax <== NOT EXECUTED 10d872: 75 38 jne 10d8ac <== NOT EXECUTED * First update the actual message queue to reflect this descriptor * being disassociated. This may result in the queue being really * deleted. */ the_mq = the_mq_fd->Queue; 10d874: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED the_mq->open_count -= 1; 10d877: ff 48 18 decl 0x18(%eax) <== NOT EXECUTED _POSIX_Message_queue_Delete( the_mq ); 10d87a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d87d: 50 push %eax <== NOT EXECUTED 10d87e: e8 3d 00 00 00 call 10d8c0 <_POSIX_Message_queue_Delete> <== NOT EXECUTED /* * Now close this file descriptor. */ _Objects_Close( 10d883: 59 pop %ecx <== NOT EXECUTED 10d884: 58 pop %eax <== NOT EXECUTED 10d885: 53 push %ebx <== NOT EXECUTED 10d886: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10d88b: e8 ec 30 00 00 call 11097c <_Objects_Close> <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure 10d890: 58 pop %eax <== NOT EXECUTED 10d891: 5a pop %edx <== NOT EXECUTED 10d892: 53 push %ebx <== NOT EXECUTED 10d893: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10d898: e8 1f 34 00 00 call 110cbc <_Objects_Free> <== NOT EXECUTED &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object ); _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 10d89d: e8 e6 3d 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED 10d8a2: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d8a4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * OBJECTS_REMOTE: * OBJECTS_ERROR: */ rtems_set_errno_and_return_minus_one( EBADF ); } 10d8a7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d8aa: c9 leave <== NOT EXECUTED 10d8ab: c3 ret <== NOT EXECUTED /* * OBJECTS_REMOTE: * OBJECTS_ERROR: */ rtems_set_errno_and_return_minus_one( EBADF ); 10d8ac: e8 9b 8c 00 00 call 11654c <__errno> <== NOT EXECUTED 10d8b1: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10d8b7: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10d8bc: eb e9 jmp 10d8a7 <== NOT EXECUTED 0010d920 : int mq_getattr( mqd_t mqdes, struct mq_attr *mqstat ) { 10d920: 55 push %ebp <== NOT EXECUTED 10d921: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d923: 53 push %ebx <== NOT EXECUTED 10d924: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10d927: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 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 ) 10d92a: 85 db test %ebx,%ebx <== NOT EXECUTED 10d92c: 74 54 je 10d982 <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 10d92e: 51 push %ecx <== NOT EXECUTED 10d92f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10d932: 50 push %eax <== NOT EXECUTED 10d933: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d936: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10d93b: e8 b0 34 00 00 call 110df0 <_Objects_Get> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 10d940: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d943: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10d946: 85 d2 test %edx,%edx <== NOT EXECUTED 10d948: 75 26 jne 10d970 <== NOT EXECUTED case OBJECTS_LOCAL: the_mq = the_mq_fd->Queue; 10d94a: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED * Return the old values. */ the_mq_attr = &the_mq->Message_queue.Attributes; mqstat->mq_flags = the_mq_fd->oflag; 10d94d: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10d950: 89 03 mov %eax,(%ebx) <== NOT EXECUTED mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size; 10d952: 8b 42 68 mov 0x68(%edx),%eax <== NOT EXECUTED 10d955: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages; 10d958: 8b 42 60 mov 0x60(%edx),%eax <== NOT EXECUTED 10d95b: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages; 10d95e: 8b 42 64 mov 0x64(%edx),%eax <== NOT EXECUTED 10d961: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10d964: e8 1f 3d 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED 10d969: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); } 10d96b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d96e: c9 leave <== NOT EXECUTED 10d96f: c3 ret <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10d970: e8 d7 8b 00 00 call 11654c <__errno> <== NOT EXECUTED 10d975: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10d97b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10d980: eb e9 jmp 10d96b <== 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 ); 10d982: e8 c5 8b 00 00 call 11654c <__errno> <== NOT EXECUTED 10d987: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10d98d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10d992: eb d7 jmp 10d96b <== NOT EXECUTED 0010d994 : int mq_notify( mqd_t mqdes, const struct sigevent *notification ) { 10d994: 55 push %ebp <== NOT EXECUTED 10d995: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d997: 57 push %edi <== NOT EXECUTED 10d998: 56 push %esi <== NOT EXECUTED 10d999: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10d99c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10d99f: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10d9a2: 50 push %eax <== NOT EXECUTED 10d9a3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d9a6: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10d9ab: e8 40 34 00 00 call 110df0 <_Objects_Get> <== NOT EXECUTED 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 ) { 10d9b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d9b3: 8b 4d f4 mov -0xc(%ebp),%ecx <== NOT EXECUTED 10d9b6: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10d9b8: 74 1a je 10d9d4 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10d9ba: e8 8d 8b 00 00 call 11654c <__errno> <== NOT EXECUTED 10d9bf: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10d9c5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10d9ca: 66 90 xchg %ax,%ax <== NOT EXECUTED } 10d9cc: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d9cf: 5e pop %esi <== NOT EXECUTED 10d9d0: 5f pop %edi <== NOT EXECUTED 10d9d1: c9 leave <== NOT EXECUTED 10d9d2: c3 ret <== NOT EXECUTED 10d9d3: 90 nop <== NOT EXECUTED the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { case OBJECTS_LOCAL: the_mq = the_mq_fd->Queue; 10d9d4: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED if ( notification ) { 10d9d7: 85 f6 test %esi,%esi <== NOT EXECUTED 10d9d9: 74 39 je 10da14 <== NOT EXECUTED if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) { 10d9db: 8b 50 7c mov 0x7c(%eax),%edx <== NOT EXECUTED 10d9de: 85 d2 test %edx,%edx <== NOT EXECUTED 10d9e0: 75 46 jne 10da28 <== NOT EXECUTED 10d9e2: c7 80 80 00 00 00 00 movl $0x0,0x80(%eax) <== NOT EXECUTED 10d9e9: 00 00 00 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBUSY ); } _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); the_mq->notification = *notification; 10d9ec: 8d b8 90 00 00 00 lea 0x90(%eax),%edi <== NOT EXECUTED 10d9f2: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 10d9f7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10d9f9: c7 40 7c 40 da 10 00 movl $0x10da40,0x7c(%eax) <== NOT EXECUTED 10da00: 89 80 80 00 00 00 mov %eax,0x80(%eax) <== NOT EXECUTED _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL, NULL ); } _Thread_Enable_dispatch(); 10da06: e8 7d 3c 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED 10da0b: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); } 10da0d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10da10: 5e pop %esi <== NOT EXECUTED 10da11: 5f pop %edi <== NOT EXECUTED 10da12: c9 leave <== NOT EXECUTED 10da13: c3 ret <== NOT EXECUTED 10da14: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%eax) <== NOT EXECUTED 10da1b: c7 80 80 00 00 00 00 movl $0x0,0x80(%eax) <== NOT EXECUTED 10da22: 00 00 00 <== NOT EXECUTED 10da25: eb df jmp 10da06 <== NOT EXECUTED 10da27: 90 nop <== NOT EXECUTED case OBJECTS_LOCAL: the_mq = the_mq_fd->Queue; if ( notification ) { if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) { _Thread_Enable_dispatch(); 10da28: e8 5b 3c 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBUSY ); 10da2d: e8 1a 8b 00 00 call 11654c <__errno> <== NOT EXECUTED 10da32: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED 10da38: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10da3d: eb 8d jmp 10d9cc <== NOT EXECUTED 0010da78 : int oflag, ... /* mode_t mode, */ /* struct mq_attr attr */ ) { 10da78: 55 push %ebp <== NOT EXECUTED 10da79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10da7b: 57 push %edi <== NOT EXECUTED 10da7c: 56 push %esi <== NOT EXECUTED 10da7d: 53 push %ebx <== NOT EXECUTED 10da7e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10da81: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10da84: a1 58 7c 12 00 mov 0x127c58,%eax <== NOT EXECUTED 10da89: 40 inc %eax <== NOT EXECUTED 10da8a: a3 58 7c 12 00 mov %eax,0x127c58 <== NOT EXECUTED POSIX_Message_queue_Control_fd *the_mq_fd; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10da8f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10da91: 25 00 02 00 00 and $0x200,%eax <== NOT EXECUTED 10da96: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 10da99: 0f 85 c5 00 00 00 jne 10db64 <== NOT EXECUTED 10da9f: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 10daa6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10daa9: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10daae: e8 49 2e 00 00 call 1108fc <_Objects_Allocate> <== NOT EXECUTED 10dab3: 89 c6 mov %eax,%esi <== NOT EXECUTED 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 ) { 10dab5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dab8: 85 c0 test %eax,%eax <== NOT EXECUTED 10daba: 0f 84 b0 00 00 00 je 10db70 <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( ENFILE ); } the_mq_fd->oflag = oflag; 10dac0: 89 58 14 mov %ebx,0x14(%eax) <== NOT EXECUTED status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); 10dac3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dac6: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10dac9: 50 push %eax <== NOT EXECUTED 10daca: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10dacd: e8 96 68 00 00 call 114368 <_POSIX_Message_queue_Name_to_id> <== NOT EXECUTED 10dad2: 89 c7 mov %eax,%edi <== NOT EXECUTED * 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 ) { 10dad4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dad7: 85 c0 test %eax,%eax <== NOT EXECUTED 10dad9: 74 35 je 10db10 <== 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) ) ) { 10dadb: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10dade: 0f 84 dc 00 00 00 je 10dbc0 <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure 10dae4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dae7: 56 push %esi <== NOT EXECUTED 10dae8: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10daed: e8 ca 31 00 00 call 110cbc <_Objects_Free> <== NOT EXECUTED _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 10daf2: e8 91 3b 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one_cast( status, mqd_t ); 10daf7: e8 50 8a 00 00 call 11654c <__errno> <== NOT EXECUTED 10dafc: 89 38 mov %edi,(%eax) <== NOT EXECUTED 10dafe: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10db03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; } 10db06: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10db09: 5b pop %ebx <== NOT EXECUTED 10db0a: 5e pop %esi <== NOT EXECUTED 10db0b: 5f pop %edi <== NOT EXECUTED 10db0c: c9 leave <== NOT EXECUTED 10db0d: c3 ret <== NOT EXECUTED 10db0e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10db10: 81 e3 00 0a 00 00 and $0xa00,%ebx <== NOT EXECUTED 10db16: 81 fb 00 0a 00 00 cmp $0xa00,%ebx <== NOT EXECUTED 10db1c: 74 72 je 10db90 <== NOT EXECUTED /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. * Any other value of @a alignment is taken "as is", i.e., even odd 10db1e: 50 push %eax <== NOT EXECUTED 10db1f: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10db22: 50 push %eax <== NOT EXECUTED 10db23: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10db26: 68 20 80 12 00 push $0x128020 <== NOT EXECUTED 10db2b: e8 c0 32 00 00 call 110df0 <_Objects_Get> <== 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 ); 10db30: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED the_mq->open_count += 1; 10db33: ff 40 18 incl 0x18(%eax) <== NOT EXECUTED the_mq_fd->Queue = the_mq; 10db36: 89 46 10 mov %eax,0x10(%esi) <== NOT EXECUTED 10db39: 0f b7 56 08 movzwl 0x8(%esi),%edx <== NOT EXECUTED 10db3d: a1 dc 81 12 00 mov 0x1281dc,%eax <== NOT EXECUTED 10db42: 89 34 90 mov %esi,(%eax,%edx,4) <== NOT EXECUTED 10db45: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) <== NOT EXECUTED _Objects_Open_string( &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 10db4c: e8 37 3b 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED _Thread_Enable_dispatch(); 10db51: e8 32 3b 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED return (mqd_t)the_mq_fd->Object.id; 10db56: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10db59: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; } 10db5c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10db5f: 5b pop %ebx <== NOT EXECUTED 10db60: 5e pop %esi <== NOT EXECUTED 10db61: 5f pop %edi <== NOT EXECUTED 10db62: c9 leave <== NOT EXECUTED 10db63: c3 ret <== 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 * ); 10db64: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10db67: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10db6a: e9 37 ff ff ff jmp 10daa6 <== NOT EXECUTED 10db6f: 90 nop <== NOT EXECUTED va_end(arg); } the_mq_fd = _POSIX_Message_queue_Allocate_fd(); if ( !the_mq_fd ) { _Thread_Enable_dispatch(); 10db70: e8 13 3b 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENFILE ); 10db75: e8 d2 89 00 00 call 11654c <__errno> <== NOT EXECUTED 10db7a: c7 00 17 00 00 00 movl $0x17,(%eax) <== NOT EXECUTED 10db80: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; } 10db85: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10db88: 5b pop %ebx <== NOT EXECUTED 10db89: 5e pop %esi <== NOT EXECUTED 10db8a: 5f pop %edi <== NOT EXECUTED 10db8b: c9 leave <== NOT EXECUTED 10db8c: c3 ret <== NOT EXECUTED 10db8d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure 10db90: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10db93: 56 push %esi <== NOT EXECUTED 10db94: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10db99: e8 1e 31 00 00 call 110cbc <_Objects_Free> <== NOT EXECUTED * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _POSIX_Message_queue_Free_fd( the_mq_fd ); _Thread_Enable_dispatch(); 10db9e: e8 e5 3a 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one_cast( EEXIST, mqd_t ); 10dba3: e8 a4 89 00 00 call 11654c <__errno> <== NOT EXECUTED 10dba8: c7 00 11 00 00 00 movl $0x11,(%eax) <== NOT EXECUTED 10dbae: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10dbb3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ); _Thread_Enable_dispatch(); return (mqd_t) the_mq_fd->Object.id; } 10dbb6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dbb9: 5b pop %ebx <== NOT EXECUTED 10dbba: 5e pop %esi <== NOT EXECUTED 10dbbb: 5f pop %edi <== NOT EXECUTED 10dbbc: c9 leave <== NOT EXECUTED 10dbbd: c3 ret <== NOT EXECUTED 10dbbe: 66 90 xchg %ax,%ax <== 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) ) ) { 10dbc0: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10dbc3: 85 d2 test %edx,%edx <== NOT EXECUTED 10dbc5: 0f 84 19 ff ff ff je 10dae4 <== NOT EXECUTED /* * At this point, the message queue does not exist and everything has been * checked. We should go ahead and create a message queue. */ status = _POSIX_Message_queue_Create_support( 10dbcb: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10dbce: 50 push %eax <== NOT EXECUTED 10dbcf: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10dbd2: 6a 01 push $0x1 <== NOT EXECUTED 10dbd4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10dbd7: e8 dc 65 00 00 call 1141b8 <_POSIX_Message_queue_Create_support> <== NOT EXECUTED /* * errno was set by Create_support, so don't set it again. */ if ( status == -1 ) { 10dbdc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dbdf: 40 inc %eax <== NOT EXECUTED 10dbe0: 75 22 jne 10dc04 <== NOT EXECUTED _Thread_Enable_dispatch(); 10dbe2: e8 a1 3a 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED 10dbe7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dbea: 56 push %esi <== NOT EXECUTED 10dbeb: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10dbf0: e8 c7 30 00 00 call 110cbc <_Objects_Free> <== NOT EXECUTED 10dbf5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10dbfa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dbfd: e9 04 ff ff ff jmp 10db06 <== NOT EXECUTED 10dc02: 66 90 xchg %ax,%ax <== NOT EXECUTED _POSIX_Message_queue_Free_fd( the_mq_fd ); return (mqd_t) -1; } the_mq_fd->Queue = the_mq; 10dc04: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10dc07: 89 46 10 mov %eax,0x10(%esi) <== NOT EXECUTED 10dc0a: 0f b7 56 08 movzwl 0x8(%esi),%edx <== NOT EXECUTED 10dc0e: a1 dc 81 12 00 mov 0x1281dc,%eax <== NOT EXECUTED 10dc13: 89 34 90 mov %esi,(%eax,%edx,4) <== NOT EXECUTED 10dc16: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) <== NOT EXECUTED &_POSIX_Message_queue_Information_fds, &the_mq_fd->Object, NULL ); _Thread_Enable_dispatch(); 10dc1d: e8 66 3a 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED return (mqd_t) the_mq_fd->Object.id; 10dc22: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10dc25: e9 dc fe ff ff jmp 10db06 <== NOT EXECUTED 0010dc2c : mqd_t mqdes, char *msg_ptr, size_t msg_len, unsigned int *msg_prio ) { 10dc2c: 55 push %ebp <== NOT EXECUTED 10dc2d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc2f: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _POSIX_Message_queue_Receive_support( 10dc32: 6a 00 push $0x0 <== NOT EXECUTED 10dc34: 6a 01 push $0x1 <== NOT EXECUTED 10dc36: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10dc39: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dc3c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dc3f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10dc42: e8 05 00 00 00 call 10dc4c <_POSIX_Message_queue_Receive_support> <== NOT EXECUTED msg_len, msg_prio, TRUE, THREAD_QUEUE_WAIT_FOREVER ); } 10dc47: c9 leave <== NOT EXECUTED 10dc48: c3 ret <== NOT EXECUTED 0010dd6c : mqd_t mqdes, const char *msg_ptr, size_t msg_len, unsigned int msg_prio ) { 10dd6c: 55 push %ebp <== NOT EXECUTED 10dd6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dd6f: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _POSIX_Message_queue_Send_support( 10dd72: 6a 00 push $0x0 <== NOT EXECUTED 10dd74: 6a 01 push $0x1 <== NOT EXECUTED 10dd76: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10dd79: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dd7c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dd7f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10dd82: e8 05 00 00 00 call 10dd8c <_POSIX_Message_queue_Send_support> <== NOT EXECUTED msg_len, msg_prio, TRUE, THREAD_QUEUE_WAIT_FOREVER ); } 10dd87: c9 leave <== NOT EXECUTED 10dd88: c3 ret <== NOT EXECUTED 0010de84 : int mq_setattr( mqd_t mqdes, const struct mq_attr *mqstat, struct mq_attr *omqstat ) { 10de84: 55 push %ebp <== NOT EXECUTED 10de85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10de87: 56 push %esi <== NOT EXECUTED 10de88: 53 push %ebx <== NOT EXECUTED 10de89: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10de8c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10de8f: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED POSIX_Message_queue_Control_fd *the_mq_fd; CORE_message_queue_Control *the_core_mq; Objects_Locations location; if ( !mqstat ) 10de92: 85 f6 test %esi,%esi <== NOT EXECUTED 10de94: 74 64 je 10defa <== NOT EXECUTED 10de96: 52 push %edx <== NOT EXECUTED 10de97: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10de9a: 50 push %eax <== NOT EXECUTED 10de9b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10de9e: 68 c0 81 12 00 push $0x1281c0 <== NOT EXECUTED 10dea3: e8 48 2f 00 00 call 110df0 <_Objects_Get> <== NOT EXECUTED 10dea8: 89 c1 mov %eax,%ecx <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location ); switch ( location ) { 10deaa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dead: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10deb0: 85 c0 test %eax,%eax <== NOT EXECUTED 10deb2: 75 34 jne 10dee8 <== NOT EXECUTED case OBJECTS_LOCAL: the_core_mq = &the_mq_fd->Queue->Message_queue; 10deb4: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED /* * Return the old values. */ if ( omqstat ) { 10deb7: 85 db test %ebx,%ebx <== NOT EXECUTED 10deb9: 74 17 je 10ded2 <== NOT EXECUTED omqstat->mq_flags = the_mq_fd->oflag; 10debb: 8b 41 14 mov 0x14(%ecx),%eax <== NOT EXECUTED 10debe: 89 03 mov %eax,(%ebx) <== NOT EXECUTED omqstat->mq_msgsize = the_core_mq->maximum_message_size; 10dec0: 8b 42 68 mov 0x68(%edx),%eax <== NOT EXECUTED 10dec3: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED omqstat->mq_maxmsg = the_core_mq->maximum_pending_messages; 10dec6: 8b 42 60 mov 0x60(%edx),%eax <== NOT EXECUTED 10dec9: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED omqstat->mq_curmsgs = the_core_mq->number_of_pending_messages; 10decc: 8b 42 64 mov 0x64(%edx),%eax <== NOT EXECUTED 10decf: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED } the_mq_fd->oflag = mqstat->mq_flags; 10ded2: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10ded4: 89 41 14 mov %eax,0x14(%ecx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10ded7: e8 ac 37 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED 10dedc: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); } 10dede: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10dee1: 5b pop %ebx <== NOT EXECUTED 10dee2: 5e pop %esi <== NOT EXECUTED 10dee3: c9 leave <== NOT EXECUTED 10dee4: c3 ret <== NOT EXECUTED 10dee5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EBADF ); 10dee8: e8 5f 86 00 00 call 11654c <__errno> <== NOT EXECUTED 10deed: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10def3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10def8: eb e4 jmp 10dede <== 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 ); 10defa: e8 4d 86 00 00 call 11654c <__errno> <== NOT EXECUTED 10deff: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10df05: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10df0a: eb d2 jmp 10dede <== NOT EXECUTED 0010df0c : char *msg_ptr, size_t msg_len, unsigned int *msg_prio, const struct timespec *abstime ) { 10df0c: 55 push %ebp <== NOT EXECUTED 10df0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df0f: 83 ec 20 sub $0x20,%esp <== 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 ) ) { 10df12: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10df15: 50 push %eax <== NOT EXECUTED 10df16: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10df19: e8 e6 00 00 00 call 10e004 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 10df1e: 5a pop %edx <== NOT EXECUTED 10df1f: 59 pop %ecx <== NOT EXECUTED 10df20: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10df23: 0f 97 c0 seta %al <== NOT EXECUTED 10df26: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED default: /* only to silence warnings */ do_wait = TRUE; break; } return _POSIX_Message_queue_Receive_support( 10df29: ff 75 fc pushl -0x4(%ebp) <== NOT EXECUTED 10df2c: 50 push %eax <== NOT EXECUTED 10df2d: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10df30: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10df33: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10df36: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10df39: e8 0e fd ff ff call 10dc4c <_POSIX_Message_queue_Receive_support> <== NOT EXECUTED msg_len, msg_prio, do_wait, ticks ); } 10df3e: c9 leave <== NOT EXECUTED 10df3f: c3 ret <== NOT EXECUTED 0010df40 : const char *msg_ptr, size_t msg_len, unsigned int msg_prio, const struct timespec *abstime ) { 10df40: 55 push %ebp <== NOT EXECUTED 10df41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df43: 83 ec 20 sub $0x20,%esp <== 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 ) ) { 10df46: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10df49: 50 push %eax <== NOT EXECUTED 10df4a: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10df4d: e8 b2 00 00 00 call 10e004 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 10df52: 5a pop %edx <== NOT EXECUTED 10df53: 59 pop %ecx <== NOT EXECUTED 10df54: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10df57: 0f 97 c0 seta %al <== NOT EXECUTED 10df5a: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED default: /* only to silence warnings */ do_wait = TRUE; break; } return _POSIX_Message_queue_Send_support( 10df5d: ff 75 fc pushl -0x4(%ebp) <== NOT EXECUTED 10df60: 50 push %eax <== NOT EXECUTED 10df61: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10df64: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10df67: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10df6a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10df6d: e8 1a fe ff ff call 10dd8c <_POSIX_Message_queue_Send_support> <== NOT EXECUTED msg_len, msg_prio, do_wait, ticks ); } 10df72: c9 leave <== NOT EXECUTED 10df73: c3 ret <== NOT EXECUTED 0010df84 : */ int mq_unlink( const char *name ) { 10df84: 55 push %ebp <== NOT EXECUTED 10df85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df87: 53 push %ebx <== NOT EXECUTED 10df88: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10df8b: a1 58 7c 12 00 mov 0x127c58,%eax <== NOT EXECUTED 10df90: 40 inc %eax <== NOT EXECUTED 10df91: a3 58 7c 12 00 mov %eax,0x127c58 <== NOT EXECUTED 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 ); 10df96: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10df99: 50 push %eax <== NOT EXECUTED 10df9a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10df9d: e8 c6 63 00 00 call 114368 <_POSIX_Message_queue_Name_to_id> <== NOT EXECUTED 10dfa2: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( status != 0 ) { 10dfa4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dfa7: 85 c0 test %eax,%eax <== NOT EXECUTED 10dfa9: 75 45 jne 10dff0 <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( status ); } the_mq = (POSIX_Message_queue_Control *) _Objects_Get_local_object( 10dfab: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 10dfae: 66 3b 05 30 80 12 00 cmp 0x128030,%ax <== NOT EXECUTED 10dfb5: 77 35 ja 10dfec <== NOT EXECUTED 10dfb7: 0f b7 d0 movzwl %ax,%edx <== NOT EXECUTED 10dfba: a1 3c 80 12 00 mov 0x12803c,%eax <== NOT EXECUTED 10dfbf: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED &_POSIX_Message_queue_Information, _Objects_Get_index( the_mq_id ) ); the_mq->linked = FALSE; 10dfc2: c6 43 15 00 movb $0x0,0x15(%ebx) <== NOT EXECUTED /** * This function attempts to allocate a block of @a size bytes from * @a the_heap. If insufficient memory is free in @a the_heap to allocate * a block of the requested size, then NULL is returned. * 10dfc6: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dfc9: 53 push %ebx <== NOT EXECUTED 10dfca: 68 20 80 12 00 push $0x128020 <== NOT EXECUTED 10dfcf: e8 40 2f 00 00 call 110f14 <_Objects_Namespace_remove> <== NOT EXECUTED _POSIX_Message_queue_Namespace_remove( the_mq ); _POSIX_Message_queue_Delete( the_mq ); 10dfd4: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10dfd7: e8 e4 f8 ff ff call 10d8c0 <_POSIX_Message_queue_Delete> <== NOT EXECUTED _Thread_Enable_dispatch(); 10dfdc: e8 a7 36 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED 10dfe1: 31 c0 xor %eax,%eax <== NOT EXECUTED 10dfe3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10dfe6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10dfe9: c9 leave <== NOT EXECUTED 10dfea: c3 ret <== NOT EXECUTED 10dfeb: 90 nop <== NOT EXECUTED bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 10dfec: 31 db xor %ebx,%ebx <== NOT EXECUTED 10dfee: eb d2 jmp 10dfc2 <== NOT EXECUTED _Thread_Disable_dispatch(); status = _POSIX_Message_queue_Name_to_id( name, &the_mq_id ); if ( status != 0 ) { _Thread_Enable_dispatch(); 10dff0: e8 93 36 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( status ); 10dff5: e8 52 85 00 00 call 11654c <__errno> <== NOT EXECUTED 10dffa: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10dffc: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e001: eb e3 jmp 10dfe6 <== NOT EXECUTED 001158a8 : int nanosleep( const struct timespec *rqtp, struct timespec *rmtp ) { 1158a8: 55 push %ebp <== NOT EXECUTED 1158a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1158ab: 56 push %esi <== NOT EXECUTED 1158ac: 53 push %ebx <== NOT EXECUTED 1158ad: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1158b0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Watchdog_Interval ticks; if ( !_Timespec_Is_valid( rqtp ) ) 1158b3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1158b6: 53 push %ebx <== NOT EXECUTED 1158b7: e8 68 17 00 00 call 117024 <_Timespec_Is_valid> <== NOT EXECUTED 1158bc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1158bf: 84 c0 test %al,%al <== NOT EXECUTED 1158c1: 0f 84 e1 00 00 00 je 1159a8 <== NOT EXECUTED * 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 ) 1158c7: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 1158c9: 85 c0 test %eax,%eax <== NOT EXECUTED 1158cb: 0f 88 d7 00 00 00 js 1159a8 <== NOT EXECUTED 1158d1: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 1158d4: 85 c0 test %eax,%eax <== NOT EXECUTED 1158d6: 0f 88 cc 00 00 00 js 1159a8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); ticks = _Timespec_To_ticks( rqtp ); 1158dc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1158df: 53 push %ebx <== NOT EXECUTED 1158e0: e8 67 17 00 00 call 11704c <_Timespec_To_ticks> <== NOT EXECUTED 1158e5: 89 c3 mov %eax,%ebx <== NOT EXECUTED * 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 ) { 1158e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1158ea: 85 c0 test %eax,%eax <== NOT EXECUTED 1158ec: 75 36 jne 115924 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1158ee: a1 b8 dc 12 00 mov 0x12dcb8,%eax <== NOT EXECUTED 1158f3: 40 inc %eax <== NOT EXECUTED 1158f4: a3 b8 dc 12 00 mov %eax,0x12dcb8 <== NOT EXECUTED _Thread_Disable_dispatch(); _Thread_Yield_processor(); 1158f9: e8 4e c4 ff ff call 111d4c <_Thread_Yield_processor> <== NOT EXECUTED _Thread_Enable_dispatch(); 1158fe: e8 55 b8 ff ff call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( rmtp ) { 115903: 85 f6 test %esi,%esi <== NOT EXECUTED 115905: 0f 84 92 00 00 00 je 11599d <== NOT EXECUTED rmtp->tv_sec = 0; 11590b: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED rmtp->tv_nsec = 0; 115911: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) <== NOT EXECUTED 115918: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( ticks ) rtems_set_errno_and_return_minus_one( EINTR ); } return 0; } 11591a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11591d: 5b pop %ebx <== NOT EXECUTED 11591e: 5e pop %esi <== NOT EXECUTED 11591f: c9 leave <== NOT EXECUTED 115920: c3 ret <== NOT EXECUTED 115921: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 115924: a1 b8 dc 12 00 mov 0x12dcb8,%eax <== NOT EXECUTED 115929: 40 inc %eax <== NOT EXECUTED 11592a: a3 b8 dc 12 00 mov %eax,0x12dcb8 <== NOT EXECUTED /* * Block for the desired amount of time */ _Thread_Disable_dispatch(); _Thread_Set_state( 11592f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 115932: 68 08 00 00 10 push $0x10000008 <== NOT EXECUTED 115937: ff 35 7c dd 12 00 pushl 0x12dd7c <== NOT EXECUTED 11593d: e8 f6 c0 ff ff call 111a38 <_Thread_Set_state> <== NOT EXECUTED _Thread_Executing, STATES_DELAYING | STATES_INTERRUPTIBLE_BY_SIGNAL ); _Watchdog_Initialize( 115942: a1 7c dd 12 00 mov 0x12dd7c,%eax <== NOT EXECUTED 115947: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 11594a: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 115951: c7 40 64 c0 0f 11 00 movl $0x110fc0,0x64(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 115958: 89 50 68 mov %edx,0x68(%eax) <== NOT EXECUTED * the heap 11595b: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 115962: 89 58 54 mov %ebx,0x54(%eax) <== NOT EXECUTED void *starting_address, size_t *size 115965: 5a pop %edx <== NOT EXECUTED 115966: 59 pop %ecx <== NOT EXECUTED 115967: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 11596a: 50 push %eax <== NOT EXECUTED 11596b: 68 9c dd 12 00 push $0x12dd9c <== NOT EXECUTED 115970: e8 af c7 ff ff call 112124 <_Watchdog_Insert> <== NOT EXECUTED _Thread_Delay_ended, _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); _Thread_Enable_dispatch(); 115975: e8 de b7 ff ff call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED /* calculate time remaining */ if ( rmtp ) { 11597a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11597d: 85 f6 test %esi,%esi <== NOT EXECUTED 11597f: 74 1c je 11599d <== NOT EXECUTED ticks -= 115981: a1 7c dd 12 00 mov 0x12dd7c,%eax <== NOT EXECUTED 115986: 03 58 5c add 0x5c(%eax),%ebx <== NOT EXECUTED 115989: 2b 58 60 sub 0x60(%eax),%ebx <== NOT EXECUTED _Thread_Executing->Timer.stop_time - _Thread_Executing->Timer.start_time; _Timespec_From_ticks( ticks, rmtp ); 11598c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11598f: 56 push %esi <== NOT EXECUTED 115990: 53 push %ebx <== NOT EXECUTED 115991: e8 46 16 00 00 call 116fdc <_Timespec_From_ticks> <== NOT EXECUTED /* * If there is time remaining, then we were interrupted by a signal. */ if ( ticks ) 115996: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115999: 85 db test %ebx,%ebx <== NOT EXECUTED 11599b: 75 22 jne 1159bf <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINTR ); 11599d: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 11599f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1159a2: 5b pop %ebx <== NOT EXECUTED 1159a3: 5e pop %esi <== NOT EXECUTED 1159a4: c9 leave <== NOT EXECUTED 1159a5: c3 ret <== NOT EXECUTED 1159a6: 66 90 xchg %ax,%ax <== NOT EXECUTED * * 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 ); 1159a8: e8 cf 3c 00 00 call 11967c <__errno> <== NOT EXECUTED 1159ad: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1159b3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED if ( ticks ) rtems_set_errno_and_return_minus_one( EINTR ); } return 0; } 1159b8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1159bb: 5b pop %ebx <== NOT EXECUTED 1159bc: 5e pop %esi <== NOT EXECUTED 1159bd: c9 leave <== NOT EXECUTED 1159be: c3 ret <== NOT EXECUTED /* * If there is time remaining, then we were interrupted by a signal. */ if ( ticks ) rtems_set_errno_and_return_minus_one( EINTR ); 1159bf: e8 b8 3c 00 00 call 11967c <__errno> <== NOT EXECUTED 1159c4: c7 00 04 00 00 00 movl $0x4,(%eax) <== NOT EXECUTED 1159ca: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1159cf: e9 46 ff ff ff jmp 11591a <== NOT EXECUTED 00107524 : */ int newlib_free_buffers( FILE *fp ) { 107524: 55 push %ebp <== NOT EXECUTED 107525: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107527: 53 push %ebx <== NOT EXECUTED 107528: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10752b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED switch ( fileno(fp) ) { 10752e: 53 push %ebx <== NOT EXECUTED 10752f: e8 38 9a 00 00 call 110f6c <== NOT EXECUTED 107534: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107537: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10753a: 76 14 jbe 107550 <== NOT EXECUTED fp->_flags &= ~__SMBF; fp->_bf._base = fp->_p = (unsigned char *) NULL; } break; default: fclose(fp); 10753c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10753f: 53 push %ebx <== NOT EXECUTED 107540: e8 87 98 00 00 call 110dcc <== NOT EXECUTED 107545: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 107548: 31 c0 xor %eax,%eax <== NOT EXECUTED 10754a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10754d: c9 leave <== NOT EXECUTED 10754e: c3 ret <== NOT EXECUTED 10754f: 90 nop <== NOT EXECUTED { switch ( fileno(fp) ) { case 0: case 1: case 2: if (fp->_flags & __SMBF) { 107550: 80 7b 0c 00 cmpb $0x0,0xc(%ebx) <== NOT EXECUTED 107554: 79 f2 jns 107548 <== NOT EXECUTED free( fp->_bf._base ); 107556: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107559: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10755c: e8 3f fb ff ff call 1070a0 <== NOT EXECUTED fp->_flags &= ~__SMBF; 107561: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) <== NOT EXECUTED fp->_bf._base = fp->_p = (unsigned char *) NULL; 107567: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED 10756d: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED 107574: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; default: fclose(fp); } return 0; } 107577: 31 c0 xor %eax,%eax <== NOT EXECUTED 107579: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10757c: c9 leave <== NOT EXECUTED 10757d: c3 ret <== NOT EXECUTED 001076b0 : rtems_device_driver null_close( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 1076b0: 55 push %ebp <== NOT EXECUTED 1076b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED return NULL_SUCCESSFUL; } 1076b3: 31 c0 xor %eax,%eax <== NOT EXECUTED 1076b5: c9 leave <== NOT EXECUTED 1076b6: c3 ret <== NOT EXECUTED 001076d4 : rtems_device_driver null_control( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 1076d4: 55 push %ebp <== NOT EXECUTED 1076d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED return NULL_SUCCESSFUL; } 1076d7: 31 c0 xor %eax,%eax <== NOT EXECUTED 1076d9: c9 leave <== NOT EXECUTED 1076da: c3 ret <== NOT EXECUTED 001076dc : rtems_device_driver null_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 1076dc: 55 push %ebp <== NOT EXECUTED 1076dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1076df: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_device_driver status; if ( !initialized ) { 1076e2: 80 3d f0 23 12 00 00 cmpb $0x0,0x1223f0 <== NOT EXECUTED 1076e9: 74 05 je 1076f0 <== NOT EXECUTED NULL_major = major; } return RTEMS_SUCCESSFUL; } 1076eb: 31 c0 xor %eax,%eax <== NOT EXECUTED 1076ed: c9 leave <== NOT EXECUTED 1076ee: c3 ret <== NOT EXECUTED 1076ef: 90 nop <== NOT EXECUTED ) { rtems_device_driver status; if ( !initialized ) { initialized = 1; 1076f0: c6 05 f0 23 12 00 01 movb $0x1,0x1223f0 <== NOT EXECUTED status = rtems_io_register_name( 1076f7: 50 push %eax <== NOT EXECUTED 1076f8: 6a 00 push $0x0 <== NOT EXECUTED 1076fa: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1076fd: 68 97 bb 11 00 push $0x11bb97 <== NOT EXECUTED 107702: e8 11 01 00 00 call 107818 <== NOT EXECUTED "/dev/null", major, (rtems_device_minor_number) 0 ); if (status != RTEMS_SUCCESSFUL) 107707: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10770a: 85 c0 test %eax,%eax <== NOT EXECUTED 10770c: 75 0c jne 10771a <== NOT EXECUTED rtems_fatal_error_occurred(status); NULL_major = major; 10770e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 107711: a3 30 26 12 00 mov %eax,0x122630 <== NOT EXECUTED } return RTEMS_SUCCESSFUL; } 107716: 31 c0 xor %eax,%eax <== NOT EXECUTED 107718: c9 leave <== NOT EXECUTED 107719: c3 ret <== NOT EXECUTED major, (rtems_device_minor_number) 0 ); if (status != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred(status); 10771a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10771d: 50 push %eax <== NOT EXECUTED 10771e: e8 65 3f 00 00 call 10b688 <== NOT EXECUTED 001076a8 : rtems_device_driver null_open( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 1076a8: 55 push %ebp <== NOT EXECUTED 1076a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED return NULL_SUCCESSFUL; } 1076ab: 31 c0 xor %eax,%eax <== NOT EXECUTED 1076ad: c9 leave <== NOT EXECUTED 1076ae: c3 ret <== NOT EXECUTED 001076b8 : rtems_device_driver null_read( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 1076b8: 55 push %ebp <== NOT EXECUTED 1076b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED return NULL_SUCCESSFUL; } 1076bb: 31 c0 xor %eax,%eax <== NOT EXECUTED 1076bd: c9 leave <== NOT EXECUTED 1076be: c3 ret <== NOT EXECUTED 001076c0 : rtems_device_driver null_write( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 1076c0: 55 push %ebp <== NOT EXECUTED 1076c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1076c3: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) pargp; if ( rw_args ) 1076c6: 85 d2 test %edx,%edx <== NOT EXECUTED 1076c8: 74 06 je 1076d0 <== NOT EXECUTED rw_args->bytes_moved = rw_args->count; 1076ca: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 1076cd: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED return NULL_SUCCESSFUL; } 1076d0: 31 c0 xor %eax,%eax <== NOT EXECUTED 1076d2: c9 leave <== NOT EXECUTED 1076d3: c3 ret <== NOT EXECUTED 0010783c : int open( const char *pathname, int flags, ... ) { 10783c: 55 push %ebp <== NOT EXECUTED 10783d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10783f: 57 push %edi <== NOT EXECUTED 107840: 56 push %esi <== NOT EXECUTED 107841: 53 push %ebx <== NOT EXECUTED 107842: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED /* * Set the Evaluation flags */ eval_flags = 0; status = flags + 1; 107845: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 107848: 40 inc %eax <== NOT EXECUTED if ( ( status & _FREAD ) == _FREAD ) 107849: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10784b: 83 e3 01 and $0x1,%ebx <== NOT EXECUTED 10784e: f7 db neg %ebx <== NOT EXECUTED 107850: 83 e3 04 and $0x4,%ebx <== NOT EXECUTED eval_flags |= RTEMS_LIBIO_PERMS_READ; if ( ( status & _FWRITE ) == _FWRITE ) 107853: a8 02 test $0x2,%al <== NOT EXECUTED 107855: 74 03 je 10785a <== NOT EXECUTED eval_flags |= RTEMS_LIBIO_PERMS_WRITE; 107857: 83 cb 02 or $0x2,%ebx <== NOT EXECUTED va_start(ap, flags); mode = va_arg( ap, int ); 10785a: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10785d: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED * 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(); 107860: e8 1f 70 00 00 call 10e884 <== NOT EXECUTED 107865: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED if ( iop == 0 ) { 107868: 85 c0 test %eax,%eax <== NOT EXECUTED 10786a: 0f 84 bc 00 00 00 je 10792c <== NOT EXECUTED /* * See if the file exists. */ status = rtems_filesystem_evaluate_path( 107870: 6a 01 push $0x1 <== NOT EXECUTED 107872: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 107875: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED 107878: 52 push %edx <== NOT EXECUTED 107879: 53 push %ebx <== NOT EXECUTED 10787a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10787d: e8 da f6 ff ff call 106f5c <== NOT EXECUTED pathname, eval_flags, &loc, true ); if ( status == -1 ) { 107882: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107885: 40 inc %eax <== NOT EXECUTED 107886: 0f 84 14 01 00 00 je 1079a0 <== NOT EXECUTED if ( status != 0 ) { /* The file did not exist */ rc = EACCES; goto done; } } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) { 10788c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10788f: 25 00 0a 00 00 and $0xa00,%eax <== NOT EXECUTED 107894: 3d 00 0a 00 00 cmp $0xa00,%eax <== NOT EXECUTED 107899: 0f 84 a9 00 00 00 je 107948 <== NOT EXECUTED /* * Fill in the file control block based on the loc structure * returned by successful path evaluation. */ iop->handlers = loc.handlers; 10789f: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1078a2: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 1078a5: 89 42 30 mov %eax,0x30(%edx) <== NOT EXECUTED iop->file_info = loc.node_access; 1078a8: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 1078ab: 89 42 2c mov %eax,0x2c(%edx) <== NOT EXECUTED iop->flags |= rtems_libio_fcntl_flags( flags ); 1078ae: 8b 5a 0c mov 0xc(%edx),%ebx <== NOT EXECUTED 1078b1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1078b4: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1078b7: e8 84 70 00 00 call 10e940 <== NOT EXECUTED 1078bc: 09 c3 or %eax,%ebx <== NOT EXECUTED 1078be: 8b 75 d4 mov -0x2c(%ebp),%esi <== NOT EXECUTED 1078c1: 89 5e 0c mov %ebx,0xc(%esi) <== NOT EXECUTED iop->pathinfo = loc; 1078c4: 89 f7 mov %esi,%edi <== NOT EXECUTED 1078c6: 83 c7 10 add $0x10,%edi <== NOT EXECUTED 1078c9: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1078ce: 8b 75 d8 mov -0x28(%ebp),%esi <== NOT EXECUTED 1078d1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !iop->handlers->open_h ) { 1078d3: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 1078d6: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 1078d9: 8b 00 mov (%eax),%eax <== NOT EXECUTED 1078db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1078de: 85 c0 test %eax,%eax <== NOT EXECUTED 1078e0: 0f 84 d6 00 00 00 je 1079bc <== NOT EXECUTED rc = ENOTSUP; goto done; } rc = (*iop->handlers->open_h)( iop, pathname, flags, mode ); 1078e6: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 1078e9: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1078ec: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1078ef: 52 push %edx <== NOT EXECUTED 1078f0: ff d0 call *%eax <== NOT EXECUTED 1078f2: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( rc ) 1078f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1078f7: 85 c0 test %eax,%eax <== NOT EXECUTED 1078f9: 74 61 je 10795c <== NOT EXECUTED 1078fb: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED done: va_end(ap); if ( rc ) { if ( iop ) rtems_libio_free( iop ); 1078fe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107901: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 107904: e8 23 6f 00 00 call 10e82c <== NOT EXECUTED 107909: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( loc_to_free ) 10790c: 85 db test %ebx,%ebx <== NOT EXECUTED 10790e: 74 21 je 107931 <== NOT EXECUTED rtems_filesystem_freenode( loc_to_free ); 107910: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 107913: 85 c0 test %eax,%eax <== NOT EXECUTED 107915: 74 1a je 107931 <== NOT EXECUTED 107917: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10791a: 85 c0 test %eax,%eax <== NOT EXECUTED 10791c: 74 13 je 107931 <== NOT EXECUTED 10791e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107921: 53 push %ebx <== NOT EXECUTED 107922: ff d0 call *%eax <== NOT EXECUTED 107924: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107927: eb 08 jmp 107931 <== NOT EXECUTED 107929: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * descriptors are obtained using socket(), not open(). */ /* allocate a file control block */ iop = rtems_libio_allocate(); if ( iop == 0 ) { 10792c: bf 17 00 00 00 mov $0x17,%edi <== NOT EXECUTED if ( rc ) { if ( iop ) rtems_libio_free( iop ); if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); rtems_set_errno_and_return_minus_one( rc ); 107931: e8 4a 93 00 00 call 110c80 <__errno> <== NOT EXECUTED 107936: 89 38 mov %edi,(%eax) <== NOT EXECUTED 107938: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } return iop - rtems_libio_iops; } 10793d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107940: 5b pop %ebx <== NOT EXECUTED 107941: 5e pop %esi <== NOT EXECUTED 107942: 5f pop %edi <== NOT EXECUTED 107943: c9 leave <== NOT EXECUTED 107944: c3 ret <== NOT EXECUTED 107945: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( status != 0 ) { /* The file did not exist */ rc = EACCES; goto done; } } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) { 107948: bf 11 00 00 00 mov $0x11,%edi <== NOT EXECUTED 10794d: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED done: va_end(ap); if ( rc ) { if ( iop ) 107950: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 107953: 85 c0 test %eax,%eax <== NOT EXECUTED 107955: 74 b5 je 10790c <== NOT EXECUTED 107957: eb a5 jmp 1078fe <== NOT EXECUTED 107959: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Optionally truncate the file. */ if ( (flags & O_TRUNC) == O_TRUNC ) { 10795c: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) <== NOT EXECUTED 107963: 0f 85 b7 00 00 00 jne 107a20 <== NOT EXECUTED if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); rtems_set_errno_and_return_minus_one( rc ); } return iop - rtems_libio_iops; 107969: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED 10796c: 2b 0d 30 f6 11 00 sub 0x11f630,%ecx <== NOT EXECUTED 107972: c1 f9 02 sar $0x2,%ecx <== NOT EXECUTED 107975: 8d 14 89 lea (%ecx,%ecx,4),%edx <== NOT EXECUTED 107978: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10797b: 89 d0 mov %edx,%eax <== NOT EXECUTED 10797d: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 107980: 29 d0 sub %edx,%eax <== NOT EXECUTED 107982: 89 c2 mov %eax,%edx <== NOT EXECUTED 107984: c1 e2 0c shl $0xc,%edx <== NOT EXECUTED 107987: 01 d0 add %edx,%eax <== NOT EXECUTED 107989: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED 10798c: 8d 04 41 lea (%ecx,%eax,2),%eax <== NOT EXECUTED 10798f: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 107992: 01 c8 add %ecx,%eax <== NOT EXECUTED 107994: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED } 107997: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10799a: 5b pop %ebx <== NOT EXECUTED 10799b: 5e pop %esi <== NOT EXECUTED 10799c: 5f pop %edi <== NOT EXECUTED 10799d: c9 leave <== NOT EXECUTED 10799e: c3 ret <== NOT EXECUTED 10799f: 90 nop <== NOT EXECUTED status = rtems_filesystem_evaluate_path( pathname, eval_flags, &loc, true ); if ( status == -1 ) { if ( errno != ENOENT ) { 1079a0: e8 db 92 00 00 call 110c80 <__errno> <== NOT EXECUTED 1079a5: 83 38 02 cmpl $0x2,(%eax) <== NOT EXECUTED 1079a8: 75 1e jne 1079c8 <== NOT EXECUTED rc = errno; goto done; } /* If the file does not exist and we are not trying to create it--> error */ if ( !(flags & O_CREAT) ) { 1079aa: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) <== NOT EXECUTED 1079b1: 75 29 jne 1079dc <== NOT EXECUTED 1079b3: bf 02 00 00 00 mov $0x2,%edi <== NOT EXECUTED 1079b8: 31 db xor %ebx,%ebx <== NOT EXECUTED 1079ba: eb 94 jmp 107950 <== NOT EXECUTED if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); rtems_set_errno_and_return_minus_one( rc ); } return iop - rtems_libio_iops; 1079bc: bf 86 00 00 00 mov $0x86,%edi <== NOT EXECUTED 1079c1: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 1079c4: eb 8a jmp 107950 <== NOT EXECUTED 1079c6: 66 90 xchg %ax,%ax <== NOT EXECUTED } /* Create the node for the new regular file */ rc = mknod( pathname, S_IFREG | mode, 0LL ); if ( rc ) { rc = errno; 1079c8: e8 b3 92 00 00 call 110c80 <__errno> <== NOT EXECUTED 1079cd: 8b 38 mov (%eax),%edi <== NOT EXECUTED */ done: va_end(ap); if ( rc ) { 1079cf: 85 ff test %edi,%edi <== NOT EXECUTED 1079d1: 74 96 je 107969 <== NOT EXECUTED 1079d3: 31 db xor %ebx,%ebx <== NOT EXECUTED 1079d5: e9 76 ff ff ff jmp 107950 <== NOT EXECUTED 1079da: 66 90 xchg %ax,%ax <== NOT EXECUTED rc = ENOENT; goto done; } /* Create the node for the new regular file */ rc = mknod( pathname, S_IFREG | mode, 0LL ); 1079dc: 6a 00 push $0x0 <== NOT EXECUTED 1079de: 6a 00 push $0x0 <== NOT EXECUTED 1079e0: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 1079e3: 80 cc 80 or $0x80,%ah <== NOT EXECUTED 1079e6: 50 push %eax <== NOT EXECUTED 1079e7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1079ea: e8 81 f9 ff ff call 107370 <== NOT EXECUTED if ( rc ) { 1079ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1079f2: 85 c0 test %eax,%eax <== NOT EXECUTED 1079f4: 75 d2 jne 1079c8 <== NOT EXECUTED rc = errno; goto done; } /* Sanity check to see if the file name exists after the mknod() */ status = rtems_filesystem_evaluate_path( pathname, 0x0, &loc, true ); 1079f6: 6a 01 push $0x1 <== NOT EXECUTED 1079f8: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 1079fb: 50 push %eax <== NOT EXECUTED 1079fc: 6a 00 push $0x0 <== NOT EXECUTED 1079fe: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107a01: e8 56 f5 ff ff call 106f5c <== NOT EXECUTED if ( status != 0 ) { /* The file did not exist */ 107a06: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107a09: 85 c0 test %eax,%eax <== NOT EXECUTED 107a0b: 0f 84 8e fe ff ff je 10789f <== NOT EXECUTED 107a11: bf 0d 00 00 00 mov $0xd,%edi <== NOT EXECUTED 107a16: 31 db xor %ebx,%ebx <== NOT EXECUTED 107a18: e9 33 ff ff ff jmp 107950 <== NOT EXECUTED 107a1d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Optionally truncate the file. */ if ( (flags & O_TRUNC) == O_TRUNC ) { rc = ftruncate( iop - rtems_libio_iops, 0 ); 107a20: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107a23: 6a 00 push $0x0 <== NOT EXECUTED 107a25: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED 107a28: 2b 0d 30 f6 11 00 sub 0x11f630,%ecx <== NOT EXECUTED 107a2e: c1 f9 02 sar $0x2,%ecx <== NOT EXECUTED 107a31: 8d 14 89 lea (%ecx,%ecx,4),%edx <== NOT EXECUTED 107a34: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 107a37: 89 d0 mov %edx,%eax <== NOT EXECUTED 107a39: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 107a3c: 29 d0 sub %edx,%eax <== NOT EXECUTED 107a3e: 89 c2 mov %eax,%edx <== NOT EXECUTED 107a40: c1 e2 0c shl $0xc,%edx <== NOT EXECUTED 107a43: 01 d0 add %edx,%eax <== NOT EXECUTED 107a45: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED 107a48: 8d 04 41 lea (%ecx,%eax,2),%eax <== NOT EXECUTED 107a4b: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 107a4e: 01 c8 add %ecx,%eax <== NOT EXECUTED 107a50: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED 107a53: 50 push %eax <== NOT EXECUTED 107a54: e8 6f 6b 00 00 call 10e5c8 <== NOT EXECUTED 107a59: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( rc ) { 107a5b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107a5e: 85 c0 test %eax,%eax <== NOT EXECUTED 107a60: 0f 84 03 ff ff ff je 107969 <== NOT EXECUTED if(errno) rc = errno; 107a66: e8 15 92 00 00 call 110c80 <__errno> <== NOT EXECUTED 107a6b: 8b 10 mov (%eax),%edx <== NOT EXECUTED 107a6d: 85 d2 test %edx,%edx <== NOT EXECUTED 107a6f: 75 46 jne 107ab7 <== NOT EXECUTED close( iop - rtems_libio_iops ); 107a71: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107a74: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED 107a77: 2b 0d 30 f6 11 00 sub 0x11f630,%ecx <== NOT EXECUTED 107a7d: c1 f9 02 sar $0x2,%ecx <== NOT EXECUTED 107a80: 8d 14 89 lea (%ecx,%ecx,4),%edx <== NOT EXECUTED 107a83: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 107a86: 89 d0 mov %edx,%eax <== NOT EXECUTED 107a88: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 107a8b: 29 d0 sub %edx,%eax <== NOT EXECUTED 107a8d: 89 c2 mov %eax,%edx <== NOT EXECUTED 107a8f: c1 e2 0c shl $0xc,%edx <== NOT EXECUTED 107a92: 01 d0 add %edx,%eax <== NOT EXECUTED 107a94: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED 107a97: 8d 04 41 lea (%ecx,%eax,2),%eax <== NOT EXECUTED 107a9a: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 107a9d: 01 c8 add %ecx,%eax <== NOT EXECUTED 107a9f: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED 107aa2: 50 push %eax <== NOT EXECUTED 107aa3: e8 88 6a 00 00 call 10e530 <== NOT EXECUTED 107aa8: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED 107aaf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107ab2: e9 18 ff ff ff jmp 1079cf <== NOT EXECUTED */ if ( (flags & O_TRUNC) == O_TRUNC ) { rc = ftruncate( iop - rtems_libio_iops, 0 ); if ( rc ) { if(errno) rc = errno; 107ab7: e8 c4 91 00 00 call 110c80 <__errno> <== NOT EXECUTED 107abc: 8b 38 mov (%eax),%edi <== NOT EXECUTED 107abe: eb b1 jmp 107a71 <== NOT EXECUTED 001077dc : /* * This is a replaceable stub */ void open_dev_console(void) { 1077dc: 55 push %ebp <== NOT EXECUTED 1077dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1077df: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED int error_code = 'S' << 24 | 'T' << 16 | 'D' << 8; /* * Attempt to open /dev/console. */ if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) { 1077e2: 6a 00 push $0x0 <== NOT EXECUTED 1077e4: 6a 00 push $0x0 <== NOT EXECUTED 1077e6: 68 10 7b 11 00 push $0x117b10 <== NOT EXECUTED 1077eb: e8 4c 00 00 00 call 10783c <== NOT EXECUTED 1077f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1077f3: 40 inc %eax <== NOT EXECUTED 1077f4: 74 2a je 107820 <== 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) 1077f6: 52 push %edx <== NOT EXECUTED 1077f7: 6a 00 push $0x0 <== NOT EXECUTED 1077f9: 6a 01 push $0x1 <== NOT EXECUTED 1077fb: 68 10 7b 11 00 push $0x117b10 <== NOT EXECUTED 107800: e8 37 00 00 00 call 10783c <== NOT EXECUTED 107805: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107808: 40 inc %eax <== NOT EXECUTED 107809: 74 24 je 10782f <== NOT EXECUTED rtems_fatal_error_occurred( error_code | '1' ); if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1) 10780b: 50 push %eax <== NOT EXECUTED 10780c: 6a 00 push $0x0 <== NOT EXECUTED 10780e: 6a 01 push $0x1 <== NOT EXECUTED 107810: 68 10 7b 11 00 push $0x117b10 <== NOT EXECUTED 107815: e8 22 00 00 00 call 10783c <== NOT EXECUTED 10781a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10781d: 40 inc %eax <== NOT EXECUTED 10781e: 74 02 je 107822 <== NOT EXECUTED rtems_fatal_error_occurred( error_code | '2' ); } 107820: c9 leave <== NOT EXECUTED 107821: c3 ret <== NOT EXECUTED */ if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1) rtems_fatal_error_occurred( error_code | '1' ); if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1) rtems_fatal_error_occurred( error_code | '2' ); 107822: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107825: 68 32 44 54 53 push $0x53544432 <== NOT EXECUTED 10782a: e8 19 32 00 00 call 10aa48 <== 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' ); 10782f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107832: 68 31 44 54 53 push $0x53544431 <== NOT EXECUTED 107837: e8 0c 32 00 00 call 10aa48 <== NOT EXECUTED 00124e14 : * open a directory. */ DIR * opendir( const char *name ) { 124e14: 55 push %ebp <== NOT EXECUTED 124e15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124e17: 56 push %esi <== NOT EXECUTED 124e18: 53 push %ebx <== NOT EXECUTED register DIR *dirp; register int fd; if ((fd = open(name, 0)) == -1) 124e19: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124e1c: 6a 00 push $0x0 <== NOT EXECUTED 124e1e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124e21: e8 96 73 fe ff call 10c1bc <== NOT EXECUTED 124e26: 89 c6 mov %eax,%esi <== NOT EXECUTED 124e28: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124e2b: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 124e2e: 74 5c je 124e8c <== NOT EXECUTED return NULL; if (fcntl(fd, F_SETFD, 1) == -1 || 124e30: 50 push %eax <== NOT EXECUTED 124e31: 6a 01 push $0x1 <== NOT EXECUTED 124e33: 6a 02 push $0x2 <== NOT EXECUTED 124e35: 56 push %esi <== NOT EXECUTED 124e36: e8 15 ab 00 00 call 12f950 <== NOT EXECUTED 124e3b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124e3e: 40 inc %eax <== NOT EXECUTED 124e3f: 74 57 je 124e98 <== NOT EXECUTED 124e41: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124e44: 6a 18 push $0x18 <== NOT EXECUTED 124e46: e8 49 6a fe ff call 10b894 <== NOT EXECUTED 124e4b: 89 c3 mov %eax,%ebx <== NOT EXECUTED 124e4d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124e50: 85 c0 test %eax,%eax <== NOT EXECUTED 124e52: 74 44 je 124e98 <== NOT EXECUTED * 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); 124e54: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124e57: 68 00 02 00 00 push $0x200 <== NOT EXECUTED 124e5c: e8 33 6a fe ff call 10b894 <== NOT EXECUTED 124e61: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED dirp->dd_len = 512; 124e64: c7 43 10 00 02 00 00 movl $0x200,0x10(%ebx) <== NOT EXECUTED if (dirp->dd_buf == NULL) { 124e6b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124e6e: 85 c0 test %eax,%eax <== NOT EXECUTED 124e70: 74 26 je 124e98 <== NOT EXECUTED close (fd); return NULL; } dirp->dd_fd = fd; 124e72: 89 33 mov %esi,(%ebx) <== NOT EXECUTED dirp->dd_loc = 0; 124e74: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED dirp->dd_seek = 0; 124e7b: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) <== NOT EXECUTED /* * Set up seek point for rewinddir. */ return dirp; } 124e82: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124e84: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 124e87: 5b pop %ebx <== NOT EXECUTED 124e88: 5e pop %esi <== NOT EXECUTED 124e89: c9 leave <== NOT EXECUTED 124e8a: c3 ret <== NOT EXECUTED 124e8b: 90 nop <== NOT EXECUTED const char *name ) { register DIR *dirp; register int fd; if ((fd = open(name, 0)) == -1) 124e8c: 31 db xor %ebx,%ebx <== NOT EXECUTED dirp->dd_seek = 0; /* * Set up seek point for rewinddir. */ return dirp; } 124e8e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124e90: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 124e93: 5b pop %ebx <== NOT EXECUTED 124e94: 5e pop %esi <== NOT EXECUTED 124e95: c9 leave <== NOT EXECUTED 124e96: c3 ret <== NOT EXECUTED 124e97: 90 nop <== NOT EXECUTED */ dirp->dd_buf = malloc (512); dirp->dd_len = 512; if (dirp->dd_buf == NULL) { close (fd); 124e98: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124e9b: 56 push %esi <== NOT EXECUTED 124e9c: e8 5b 62 fe ff call 10b0fc <== NOT EXECUTED 124ea1: 31 db xor %ebx,%ebx <== NOT EXECUTED 124ea3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED dirp->dd_seek = 0; /* * Set up seek point for rewinddir. */ return dirp; } 124ea6: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124ea8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 124eab: 5b pop %ebx <== NOT EXECUTED 124eac: 5e pop %esi <== NOT EXECUTED 124ead: c9 leave <== NOT EXECUTED 124eae: c3 ret <== NOT EXECUTED 0010867c : /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) { 10867c: 55 push %ebp <== NOT EXECUTED 10867d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10867f: 56 push %esi <== NOT EXECUTED 108680: 53 push %ebx <== NOT EXECUTED 108681: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 108684: 89 d3 mov %edx,%ebx <== NOT EXECUTED 108686: 88 45 f4 mov %al,-0xc(%ebp) <== NOT EXECUTED int i; if (tty->termios.c_oflag & OPOST) { 108689: 8b 52 34 mov 0x34(%edx),%edx <== NOT EXECUTED 10868c: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 10868f: 74 17 je 1086a8 <== NOT EXECUTED switch (c) { 108691: 3c 09 cmp $0x9,%al <== NOT EXECUTED 108693: 74 53 je 1086e8 <== NOT EXECUTED 108695: 77 29 ja 1086c0 <== NOT EXECUTED 108697: 3c 08 cmp $0x8,%al <== NOT EXECUTED 108699: 75 2d jne 1086c8 <== NOT EXECUTED } tty->column += i; break; case '\b': if (tty->column > 0) 10869b: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10869e: 85 c0 test %eax,%eax <== NOT EXECUTED 1086a0: 7e 06 jle 1086a8 <== NOT EXECUTED tty->column--; 1086a2: 48 dec %eax <== NOT EXECUTED 1086a3: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 1086a6: 66 90 xchg %ax,%ax <== NOT EXECUTED if (!iscntrl(c)) tty->column++; break; } } rtems_termios_puts (&c, 1, tty); 1086a8: 56 push %esi <== NOT EXECUTED 1086a9: 53 push %ebx <== NOT EXECUTED 1086aa: 6a 01 push $0x1 <== NOT EXECUTED 1086ac: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1086af: 50 push %eax <== NOT EXECUTED 1086b0: e8 97 fe ff ff call 10854c <== NOT EXECUTED 1086b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1086b8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1086bb: 5b pop %ebx <== NOT EXECUTED 1086bc: 5e pop %esi <== NOT EXECUTED 1086bd: c9 leave <== NOT EXECUTED 1086be: c3 ret <== NOT EXECUTED 1086bf: 90 nop <== NOT EXECUTED oproc (unsigned char c, struct rtems_termios_tty *tty) { int i; if (tty->termios.c_oflag & OPOST) { switch (c) { 1086c0: 3c 0a cmp $0xa,%al <== NOT EXECUTED 1086c2: 74 50 je 108714 <== NOT EXECUTED 1086c4: 3c 0d cmp $0xd,%al <== NOT EXECUTED 1086c6: 74 7c je 108744 <== NOT EXECUTED if (tty->column > 0) tty->column--; break; default: if (tty->termios.c_oflag & OLCUC) 1086c8: 83 e2 02 and $0x2,%edx <== NOT EXECUTED 1086cb: 0f 85 a3 00 00 00 jne 108774 <== NOT EXECUTED 1086d1: 8b 15 34 d6 11 00 mov 0x11d634,%edx <== NOT EXECUTED c = toupper(c); if (!iscntrl(c)) 1086d7: 0f b6 45 f4 movzbl -0xc(%ebp),%eax <== NOT EXECUTED 1086db: f6 04 02 20 testb $0x20,(%edx,%eax,1) <== NOT EXECUTED 1086df: 75 c7 jne 1086a8 <== NOT EXECUTED tty->column++; 1086e1: ff 43 28 incl 0x28(%ebx) <== NOT EXECUTED 1086e4: eb c2 jmp 1086a8 <== NOT EXECUTED 1086e6: 66 90 xchg %ax,%ax <== NOT EXECUTED } tty->column = 0; break; case '\t': i = 8 - (tty->column & 7); 1086e8: 8b 73 28 mov 0x28(%ebx),%esi <== NOT EXECUTED 1086eb: 89 f0 mov %esi,%eax <== NOT EXECUTED 1086ed: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 1086f0: b9 08 00 00 00 mov $0x8,%ecx <== NOT EXECUTED 1086f5: 29 c1 sub %eax,%ecx <== NOT EXECUTED if ((tty->termios.c_oflag & TABDLY) == XTABS) { 1086f7: 81 e2 00 18 00 00 and $0x1800,%edx <== NOT EXECUTED 1086fd: 81 fa 00 18 00 00 cmp $0x1800,%edx <== NOT EXECUTED 108703: 0f 84 87 00 00 00 je 108790 <== NOT EXECUTED tty->column += i; rtems_termios_puts ( " ", i, tty); return; } tty->column += i; 108709: 8d 04 31 lea (%ecx,%esi,1),%eax <== NOT EXECUTED 10870c: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 10870f: eb 97 jmp 1086a8 <== NOT EXECUTED 108711: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED int i; if (tty->termios.c_oflag & OPOST) { switch (c) { case '\n': if (tty->termios.c_oflag & ONLRET) 108714: f6 c2 20 test $0x20,%dl <== NOT EXECUTED 108717: 74 07 je 108720 <== NOT EXECUTED tty->column = 0; 108719: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED if (tty->termios.c_oflag & ONLCR) { 108720: 83 e2 04 and $0x4,%edx <== NOT EXECUTED 108723: 74 83 je 1086a8 <== NOT EXECUTED rtems_termios_puts ("\r", 1, tty); 108725: 50 push %eax <== NOT EXECUTED 108726: 53 push %ebx <== NOT EXECUTED 108727: 6a 01 push $0x1 <== NOT EXECUTED 108729: 68 d8 8f 11 00 push $0x118fd8 <== NOT EXECUTED 10872e: e8 19 fe ff ff call 10854c <== NOT EXECUTED tty->column = 0; 108733: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED 10873a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10873d: e9 66 ff ff ff jmp 1086a8 <== NOT EXECUTED 108742: 66 90 xchg %ax,%ax <== NOT EXECUTED } break; case '\r': if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0)) 108744: f6 c2 10 test $0x10,%dl <== NOT EXECUTED 108747: 74 0b je 108754 <== NOT EXECUTED 108749: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10874c: 85 c0 test %eax,%eax <== NOT EXECUTED 10874e: 0f 84 64 ff ff ff je 1086b8 <== NOT EXECUTED return; if (tty->termios.c_oflag & OCRNL) { 108754: f6 c2 08 test $0x8,%dl <== NOT EXECUTED 108757: 74 0d je 108766 <== NOT EXECUTED c = '\n'; 108759: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED if (tty->termios.c_oflag & ONLRET) 10875d: 83 e2 20 and $0x20,%edx <== NOT EXECUTED 108760: 0f 84 42 ff ff ff je 1086a8 <== NOT EXECUTED tty->column = 0; break; } tty->column = 0; 108766: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED 10876d: e9 36 ff ff ff jmp 1086a8 <== NOT EXECUTED 108772: 66 90 xchg %ax,%ax <== NOT EXECUTED tty->column--; break; default: if (tty->termios.c_oflag & OLCUC) c = toupper(c); 108774: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 108777: 8b 15 34 d6 11 00 mov 0x11d634,%edx <== NOT EXECUTED 10877d: f6 04 02 02 testb $0x2,(%edx,%eax,1) <== NOT EXECUTED 108781: 74 03 je 108786 <== NOT EXECUTED 108783: 83 e8 20 sub $0x20,%eax <== NOT EXECUTED 108786: 88 45 f4 mov %al,-0xc(%ebp) <== NOT EXECUTED 108789: e9 49 ff ff ff jmp 1086d7 <== NOT EXECUTED 10878e: 66 90 xchg %ax,%ax <== NOT EXECUTED break; case '\t': i = 8 - (tty->column & 7); if ((tty->termios.c_oflag & TABDLY) == XTABS) { tty->column += i; 108790: 8d 04 31 lea (%ecx,%esi,1),%eax <== NOT EXECUTED 108793: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED rtems_termios_puts ( " ", i, tty); 108796: 50 push %eax <== NOT EXECUTED 108797: 53 push %ebx <== NOT EXECUTED 108798: 51 push %ecx <== NOT EXECUTED 108799: 68 da 8f 11 00 push $0x118fda <== NOT EXECUTED 10879e: e8 a9 fd ff ff call 10854c <== NOT EXECUTED 1087a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1087a6: e9 0d ff ff ff jmp 1086b8 <== NOT EXECUTED 00109110 : long pathconf( const char *path, int name ) { 109110: 55 push %ebp <== NOT EXECUTED 109111: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109113: 56 push %esi <== NOT EXECUTED 109114: 53 push %ebx <== NOT EXECUTED int status; int fd; fd = open( path, O_RDONLY ); 109115: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109118: 6a 00 push $0x0 <== NOT EXECUTED 10911a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10911d: e8 4e fd ff ff call 108e70 <== NOT EXECUTED 109122: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( fd == -1 ) 109124: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109127: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10912a: 74 24 je 109150 <== NOT EXECUTED return -1; status = fpathconf( fd, name ); 10912c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10912f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109132: 50 push %eax <== NOT EXECUTED 109133: e8 00 f0 ff ff call 108138 <== NOT EXECUTED 109138: 89 c6 mov %eax,%esi <== NOT EXECUTED (void) close( fd ); 10913a: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10913d: e8 c2 ea ff ff call 107c04 <== NOT EXECUTED 109142: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return status; } 109145: 89 f0 mov %esi,%eax <== NOT EXECUTED 109147: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10914a: 5b pop %ebx <== NOT EXECUTED 10914b: 5e pop %esi <== NOT EXECUTED 10914c: c9 leave <== NOT EXECUTED 10914d: c3 ret <== NOT EXECUTED 10914e: 66 90 xchg %ax,%ax <== NOT EXECUTED { int status; int fd; fd = open( path, O_RDONLY ); if ( fd == -1 ) 109150: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED status = fpathconf( fd, name ); (void) close( fd ); return status; } 109155: 89 f0 mov %esi,%eax <== NOT EXECUTED 109157: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10915a: 5b pop %ebx <== NOT EXECUTED 10915b: 5e pop %esi <== NOT EXECUTED 10915c: c9 leave <== NOT EXECUTED 10915d: c3 ret <== NOT EXECUTED 0010bd5c : /* * 3.4.2 Suspend Process Execution, P1003.1b-1993, p. 81 */ int pause( void ) { 10bd5c: 55 push %ebp <== NOT EXECUTED 10bd5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd5f: 53 push %ebx <== NOT EXECUTED 10bd60: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED sigset_t all_signals; int status; (void) sigfillset( &all_signals ); 10bd63: 8d 5d f8 lea -0x8(%ebp),%ebx <== NOT EXECUTED 10bd66: 53 push %ebx <== NOT EXECUTED 10bd67: e8 48 0a 00 00 call 10c7b4 <== NOT EXECUTED status = sigtimedwait( &all_signals, NULL, NULL ); 10bd6c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10bd6f: 6a 00 push $0x0 <== NOT EXECUTED 10bd71: 6a 00 push $0x0 <== NOT EXECUTED 10bd73: 53 push %ebx <== NOT EXECUTED 10bd74: e8 b7 0b 00 00 call 10c930 <== NOT EXECUTED return status; } 10bd79: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bd7c: c9 leave <== NOT EXECUTED 10bd7d: c3 ret <== NOT EXECUTED 00109160 : #include int pipe( int filsdes[2] ) { 109160: 55 push %ebp <== NOT EXECUTED 109161: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109163: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED errno = ENOSYS; 109166: e8 cd 9f 00 00 call 113138 <__errno> <== NOT EXECUTED 10916b: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED return -1; } 109171: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 109176: c9 leave <== NOT EXECUTED 109177: c3 ret <== NOT EXECUTED 0010903c : int posix_memalign( void **pointer, size_t alignment, size_t size ) { 10903c: 55 push %ebp <== NOT EXECUTED 10903d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10903f: 53 push %ebx <== NOT EXECUTED 109040: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED /* * Update call statistics */ MSBUMP(memalign_calls, 1); 109043: ff 05 68 4d 12 00 incl 0x124d68 <== NOT EXECUTED if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *))) 109049: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10904c: 85 d0 test %edx,%eax <== NOT EXECUTED 10904e: 75 05 jne 109055 <== NOT EXECUTED 109050: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 109053: 77 0b ja 109060 <== NOT EXECUTED /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); } 109055: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10905a: 5b pop %ebx <== NOT EXECUTED 10905b: c9 leave <== NOT EXECUTED 10905c: c3 ret <== NOT EXECUTED 10905d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 109060: 5b pop %ebx <== NOT EXECUTED 109061: c9 leave <== NOT EXECUTED /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); 109062: e9 35 04 00 00 jmp 10949c <== NOT EXECUTED 00107df4 : * printk * * Kernel printf function requiring minimal infrastrure. */ void printk(const char *fmt, ...) { 107df4: 55 push %ebp <== NOT EXECUTED 107df5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107df7: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 107dfa: 8d 45 0c lea 0xc(%ebp),%eax <== NOT EXECUTED va_list ap; /* points to each unnamed argument in turn */ va_start(ap, fmt); /* make ap point to 1st unnamed arg */ vprintk(fmt, ap); 107dfd: 50 push %eax <== NOT EXECUTED 107dfe: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107e01: e8 d6 fc ff ff call 107adc <== NOT EXECUTED 107e06: 83 c4 10 add $0x10,%esp <== NOT EXECUTED va_end(ap); /* clean up when done */ } 107e09: c9 leave <== NOT EXECUTED 107e0a: c3 ret <== NOT EXECUTED 00108ca0 : int printk_plugin( void *ignored, const char *format, ... ) { 108ca0: 55 push %ebp <== NOT EXECUTED 108ca1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108ca3: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 108ca6: 8d 45 10 lea 0x10(%ebp),%eax <== NOT EXECUTED va_list arg_pointer; va_start (arg_pointer, format); vprintk( format, arg_pointer ); 108ca9: 50 push %eax <== NOT EXECUTED 108caa: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 108cad: e8 be fc ff ff call 108970 <== NOT EXECUTED va_end(arg_pointer); /* clean up when done */ return 0; } 108cb2: 31 c0 xor %eax,%eax <== NOT EXECUTED 108cb4: c9 leave <== NOT EXECUTED 108cb5: c3 ret <== NOT EXECUTED 0010a3a8 : int pthread_atfork( void (*prepare)(void), void (*parent)(void), void (*child)(void) ) { 10a3a8: 55 push %ebp <== NOT EXECUTED 10a3a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a3ab: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a3ae: e8 cd 76 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a3b3: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a3b9: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a3be: c9 leave <== NOT EXECUTED 10a3bf: c3 ret <== NOT EXECUTED 0010dd78 : #include int pthread_attr_destroy( pthread_attr_t *attr ) { 10dd78: 55 push %ebp <== NOT EXECUTED 10dd79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dd7b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10dd7e: 85 c0 test %eax,%eax <== NOT EXECUTED 10dd80: 74 12 je 10dd94 <== NOT EXECUTED 10dd82: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10dd84: 85 d2 test %edx,%edx <== NOT EXECUTED 10dd86: 74 0c je 10dd94 <== NOT EXECUTED return EINVAL; attr->is_initialized = FALSE; 10dd88: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10dd8e: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10dd90: c9 leave <== NOT EXECUTED 10dd91: c3 ret <== NOT EXECUTED 10dd92: 66 90 xchg %ax,%ax <== NOT EXECUTED { if ( !attr || !attr->is_initialized ) return EINVAL; attr->is_initialized = FALSE; return 0; 10dd94: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10dd99: c9 leave <== NOT EXECUTED 10dd9a: c3 ret <== NOT EXECUTED 0010e404 : int pthread_attr_getcputime( pthread_attr_t *attr, int *clock_allowed ) { 10e404: 55 push %ebp <== NOT EXECUTED 10e405: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e407: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e40a: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !clock_allowed ) 10e40d: 85 c0 test %eax,%eax <== NOT EXECUTED 10e40f: 74 13 je 10e424 <== NOT EXECUTED 10e411: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10e413: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10e415: 74 0d je 10e424 <== NOT EXECUTED 10e417: 85 d2 test %edx,%edx <== NOT EXECUTED 10e419: 74 09 je 10e424 <== NOT EXECUTED return EINVAL; *clock_allowed = attr->cputime_clock_allowed; 10e41b: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED 10e41e: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10e420: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10e422: c9 leave <== NOT EXECUTED 10e423: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !clock_allowed ) return EINVAL; *clock_allowed = attr->cputime_clock_allowed; return 0; 10e424: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10e429: c9 leave <== NOT EXECUTED 10e42a: c3 ret <== NOT EXECUTED 0010dd9c : int pthread_attr_getdetachstate( const pthread_attr_t *attr, int *detachstate ) { 10dd9c: 55 push %ebp <== NOT EXECUTED 10dd9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dd9f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10dda2: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !detachstate ) 10dda5: 85 c0 test %eax,%eax <== NOT EXECUTED 10dda7: 74 13 je 10ddbc <== NOT EXECUTED 10dda9: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10ddab: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ddad: 74 0d je 10ddbc <== NOT EXECUTED 10ddaf: 85 d2 test %edx,%edx <== NOT EXECUTED 10ddb1: 74 09 je 10ddbc <== NOT EXECUTED return EINVAL; *detachstate = attr->detachstate; 10ddb3: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED 10ddb6: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10ddb8: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10ddba: c9 leave <== NOT EXECUTED 10ddbb: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !detachstate ) return EINVAL; *detachstate = attr->detachstate; return 0; 10ddbc: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10ddc1: c9 leave <== NOT EXECUTED 10ddc2: c3 ret <== NOT EXECUTED 0010ddc4 : int pthread_attr_getinheritsched( const pthread_attr_t *attr, int *inheritsched ) { 10ddc4: 55 push %ebp <== NOT EXECUTED 10ddc5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ddc7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ddca: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !inheritsched ) 10ddcd: 85 c0 test %eax,%eax <== NOT EXECUTED 10ddcf: 74 13 je 10dde4 <== NOT EXECUTED 10ddd1: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10ddd3: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ddd5: 74 0d je 10dde4 <== NOT EXECUTED 10ddd7: 85 d2 test %edx,%edx <== NOT EXECUTED 10ddd9: 74 09 je 10dde4 <== NOT EXECUTED return EINVAL; *inheritsched = attr->inheritsched; 10dddb: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 10ddde: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10dde0: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10dde2: c9 leave <== NOT EXECUTED 10dde3: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !inheritsched ) return EINVAL; *inheritsched = attr->inheritsched; return 0; 10dde4: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10dde9: c9 leave <== NOT EXECUTED 10ddea: c3 ret <== NOT EXECUTED 0010ddec : int pthread_attr_getschedparam( const pthread_attr_t *attr, struct sched_param *param ) { 10ddec: 55 push %ebp <== NOT EXECUTED 10dded: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ddef: 57 push %edi <== NOT EXECUTED 10ddf0: 56 push %esi <== NOT EXECUTED 10ddf1: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10ddf4: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ddf7: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED if ( !attr || !attr->is_initialized || !param ) 10ddfa: 85 c0 test %eax,%eax <== NOT EXECUTED 10ddfc: 74 1e je 10de1c <== NOT EXECUTED 10ddfe: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10de00: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10de02: 74 18 je 10de1c <== NOT EXECUTED 10de04: 85 ff test %edi,%edi <== NOT EXECUTED 10de06: 74 14 je 10de1c <== NOT EXECUTED return EINVAL; *param = attr->schedparam; 10de08: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 10de0b: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10de10: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10de12: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10de14: 5a pop %edx <== NOT EXECUTED 10de15: 5e pop %esi <== NOT EXECUTED 10de16: 5f pop %edi <== NOT EXECUTED 10de17: c9 leave <== NOT EXECUTED 10de18: c3 ret <== NOT EXECUTED 10de19: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !param ) return EINVAL; *param = attr->schedparam; return 0; 10de1c: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10de21: 5a pop %edx <== NOT EXECUTED 10de22: 5e pop %esi <== NOT EXECUTED 10de23: 5f pop %edi <== NOT EXECUTED 10de24: c9 leave <== NOT EXECUTED 10de25: c3 ret <== NOT EXECUTED 0010de28 : int pthread_attr_getschedpolicy( const pthread_attr_t *attr, int *policy ) { 10de28: 55 push %ebp <== NOT EXECUTED 10de29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10de2b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10de2e: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !policy ) 10de31: 85 c0 test %eax,%eax <== NOT EXECUTED 10de33: 74 13 je 10de48 <== NOT EXECUTED 10de35: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10de37: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10de39: 74 0d je 10de48 <== NOT EXECUTED 10de3b: 85 d2 test %edx,%edx <== NOT EXECUTED 10de3d: 74 09 je 10de48 <== NOT EXECUTED return EINVAL; *policy = attr->schedpolicy; 10de3f: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10de42: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10de44: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10de46: c9 leave <== NOT EXECUTED 10de47: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !policy ) return EINVAL; *policy = attr->schedpolicy; return 0; 10de48: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10de4d: c9 leave <== NOT EXECUTED 10de4e: c3 ret <== NOT EXECUTED 0010de50 : int pthread_attr_getscope( const pthread_attr_t *attr, int *contentionscope ) { 10de50: 55 push %ebp <== NOT EXECUTED 10de51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10de53: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10de56: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !contentionscope ) 10de59: 85 c0 test %eax,%eax <== NOT EXECUTED 10de5b: 74 13 je 10de70 <== NOT EXECUTED 10de5d: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10de5f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10de61: 74 0d je 10de70 <== NOT EXECUTED 10de63: 85 d2 test %edx,%edx <== NOT EXECUTED 10de65: 74 09 je 10de70 <== NOT EXECUTED return EINVAL; *contentionscope = attr->contentionscope; 10de67: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10de6a: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10de6c: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10de6e: c9 leave <== NOT EXECUTED 10de6f: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !contentionscope ) return EINVAL; *contentionscope = attr->contentionscope; return 0; 10de70: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10de75: c9 leave <== NOT EXECUTED 10de76: c3 ret <== NOT EXECUTED 0010de78 : int pthread_attr_getstackaddr( const pthread_attr_t *attr, void **stackaddr ) { 10de78: 55 push %ebp <== NOT EXECUTED 10de79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10de7b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10de7e: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !stackaddr ) 10de81: 85 c0 test %eax,%eax <== NOT EXECUTED 10de83: 74 13 je 10de98 <== NOT EXECUTED 10de85: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10de87: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10de89: 74 0d je 10de98 <== NOT EXECUTED 10de8b: 85 d2 test %edx,%edx <== NOT EXECUTED 10de8d: 74 09 je 10de98 <== NOT EXECUTED return EINVAL; *stackaddr = attr->stackaddr; 10de8f: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10de92: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10de94: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10de96: c9 leave <== NOT EXECUTED 10de97: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !stackaddr ) return EINVAL; *stackaddr = attr->stackaddr; return 0; 10de98: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10de9d: c9 leave <== NOT EXECUTED 10de9e: c3 ret <== NOT EXECUTED 0010dea0 : int pthread_attr_getstacksize( const pthread_attr_t *attr, size_t *stacksize ) { 10dea0: 55 push %ebp <== NOT EXECUTED 10dea1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dea3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10dea6: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !stacksize ) 10dea9: 85 c0 test %eax,%eax <== NOT EXECUTED 10deab: 74 13 je 10dec0 <== NOT EXECUTED 10dead: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10deaf: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10deb1: 74 0d je 10dec0 <== NOT EXECUTED 10deb3: 85 d2 test %edx,%edx <== NOT EXECUTED 10deb5: 74 09 je 10dec0 <== NOT EXECUTED return EINVAL; *stacksize = attr->stacksize; 10deb7: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10deba: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10debc: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10debe: c9 leave <== NOT EXECUTED 10debf: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !stacksize ) return EINVAL; *stacksize = attr->stacksize; return 0; 10dec0: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10dec5: c9 leave <== NOT EXECUTED 10dec6: c3 ret <== NOT EXECUTED 00110e60 : #include int pthread_attr_init( pthread_attr_t *attr ) { 110e60: 55 push %ebp <== NOT EXECUTED 110e61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110e63: 57 push %edi <== NOT EXECUTED 110e64: 56 push %esi <== NOT EXECUTED 110e65: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 110e68: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED if ( !attr ) 110e6b: 85 ff test %edi,%edi <== NOT EXECUTED 110e6d: 74 15 je 110e84 <== NOT EXECUTED return EINVAL; *attr = _POSIX_Threads_Default_attributes; 110e6f: be a0 c9 11 00 mov $0x11c9a0,%esi <== NOT EXECUTED 110e74: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 110e79: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 110e7b: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 110e7d: 5a pop %edx <== NOT EXECUTED 110e7e: 5e pop %esi <== NOT EXECUTED 110e7f: 5f pop %edi <== NOT EXECUTED 110e80: c9 leave <== NOT EXECUTED 110e81: c3 ret <== NOT EXECUTED 110e82: 66 90 xchg %ax,%ax <== NOT EXECUTED int pthread_attr_init( pthread_attr_t *attr ) { if ( !attr ) 110e84: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return EINVAL; *attr = _POSIX_Threads_Default_attributes; return 0; } 110e89: 5a pop %edx <== NOT EXECUTED 110e8a: 5e pop %esi <== NOT EXECUTED 110e8b: 5f pop %edi <== NOT EXECUTED 110e8c: c9 leave <== NOT EXECUTED 110e8d: c3 ret <== NOT EXECUTED 0010e8dc : int pthread_attr_setcputime( pthread_attr_t *attr, int clock_allowed ) { 10e8dc: 55 push %ebp <== NOT EXECUTED 10e8dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e8df: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10e8e2: 85 c0 test %eax,%eax <== NOT EXECUTED 10e8e4: 74 0c je 10e8f2 <== NOT EXECUTED 10e8e6: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10e8e8: 85 d2 test %edx,%edx <== NOT EXECUTED 10e8ea: 74 06 je 10e8f2 <== NOT EXECUTED return EINVAL; switch ( clock_allowed ) { 10e8ec: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10e8f0: 76 0a jbe 10e8fc <== NOT EXECUTED case CLOCK_ENABLED: case CLOCK_DISABLED: attr->cputime_clock_allowed = clock_allowed; return 0; 10e8f2: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10e8f7: c9 leave <== NOT EXECUTED 10e8f8: c3 ret <== NOT EXECUTED 10e8f9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return EINVAL; switch ( clock_allowed ) { case CLOCK_ENABLED: case CLOCK_DISABLED: attr->cputime_clock_allowed = clock_allowed; 10e8fc: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10e8ff: 89 50 30 mov %edx,0x30(%eax) <== NOT EXECUTED 10e902: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return EINVAL; } } 10e904: c9 leave <== NOT EXECUTED 10e905: c3 ret <== NOT EXECUTED 0010def8 : int pthread_attr_setdetachstate( pthread_attr_t *attr, int detachstate ) { 10def8: 55 push %ebp <== NOT EXECUTED 10def9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10defb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10defe: 85 c0 test %eax,%eax <== NOT EXECUTED 10df00: 74 0c je 10df0e <== NOT EXECUTED 10df02: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10df04: 85 d2 test %edx,%edx <== NOT EXECUTED 10df06: 74 06 je 10df0e <== NOT EXECUTED return EINVAL; switch ( detachstate ) { 10df08: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10df0c: 76 0a jbe 10df18 <== NOT EXECUTED case PTHREAD_CREATE_DETACHED: case PTHREAD_CREATE_JOINABLE: attr->detachstate = detachstate; return 0; 10df0e: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10df13: c9 leave <== NOT EXECUTED 10df14: c3 ret <== NOT EXECUTED 10df15: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return EINVAL; switch ( detachstate ) { case PTHREAD_CREATE_DETACHED: case PTHREAD_CREATE_JOINABLE: attr->detachstate = detachstate; 10df18: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10df1b: 89 50 34 mov %edx,0x34(%eax) <== NOT EXECUTED 10df1e: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return EINVAL; } } 10df20: c9 leave <== NOT EXECUTED 10df21: c3 ret <== NOT EXECUTED 00110e90 : int pthread_attr_setinheritsched( pthread_attr_t *attr, int inheritsched ) { 110e90: 55 push %ebp <== NOT EXECUTED 110e91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110e93: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 110e96: 85 d2 test %edx,%edx <== NOT EXECUTED 110e98: 74 22 je 110ebc <== NOT EXECUTED 110e9a: 8b 02 mov (%edx),%eax <== NOT EXECUTED 110e9c: 85 c0 test %eax,%eax <== NOT EXECUTED 110e9e: 74 1c je 110ebc <== NOT EXECUTED return EINVAL; switch ( inheritsched ) { 110ea0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 110ea3: 48 dec %eax <== NOT EXECUTED 110ea4: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 110ea7: 76 07 jbe 110eb0 <== NOT EXECUTED 110ea9: b8 86 00 00 00 mov $0x86,%eax <== NOT EXECUTED return 0; default: return ENOTSUP; } } 110eae: c9 leave <== NOT EXECUTED 110eaf: c3 ret <== NOT EXECUTED return EINVAL; switch ( inheritsched ) { case PTHREAD_INHERIT_SCHED: case PTHREAD_EXPLICIT_SCHED: attr->inheritsched = inheritsched; 110eb0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 110eb3: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED 110eb6: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return ENOTSUP; } } 110eb8: c9 leave <== NOT EXECUTED 110eb9: c3 ret <== NOT EXECUTED 110eba: 66 90 xchg %ax,%ax <== NOT EXECUTED switch ( inheritsched ) { case PTHREAD_INHERIT_SCHED: case PTHREAD_EXPLICIT_SCHED: attr->inheritsched = inheritsched; return 0; 110ebc: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return ENOTSUP; } } 110ec1: c9 leave <== NOT EXECUTED 110ec2: c3 ret <== NOT EXECUTED 0010df58 : int pthread_attr_setschedparam( pthread_attr_t *attr, const struct sched_param *param ) { 10df58: 55 push %ebp <== NOT EXECUTED 10df59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df5b: 57 push %edi <== NOT EXECUTED 10df5c: 56 push %esi <== NOT EXECUTED 10df5d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10df60: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED if ( !attr || !attr->is_initialized || !param ) 10df63: 85 c0 test %eax,%eax <== NOT EXECUTED 10df65: 74 1d je 10df84 <== NOT EXECUTED 10df67: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10df69: 85 d2 test %edx,%edx <== NOT EXECUTED 10df6b: 74 17 je 10df84 <== NOT EXECUTED 10df6d: 85 f6 test %esi,%esi <== NOT EXECUTED 10df6f: 74 13 je 10df84 <== NOT EXECUTED return EINVAL; attr->schedparam = *param; 10df71: 8d 78 18 lea 0x18(%eax),%edi <== NOT EXECUTED 10df74: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10df79: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10df7b: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10df7d: 5e pop %esi <== NOT EXECUTED 10df7e: 5f pop %edi <== NOT EXECUTED 10df7f: c9 leave <== NOT EXECUTED 10df80: c3 ret <== NOT EXECUTED 10df81: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !param ) return EINVAL; attr->schedparam = *param; return 0; 10df84: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10df89: 5e pop %esi <== NOT EXECUTED 10df8a: 5f pop %edi <== NOT EXECUTED 10df8b: c9 leave <== NOT EXECUTED 10df8c: c3 ret <== NOT EXECUTED 0010df90 : int pthread_attr_setschedpolicy( pthread_attr_t *attr, int policy ) { 10df90: 55 push %ebp <== NOT EXECUTED 10df91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df93: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10df96: 85 c0 test %eax,%eax <== NOT EXECUTED 10df98: 74 22 je 10dfbc <== NOT EXECUTED 10df9a: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10df9c: 85 d2 test %edx,%edx <== NOT EXECUTED 10df9e: 74 1c je 10dfbc <== NOT EXECUTED return EINVAL; switch ( policy ) { 10dfa0: 83 7d 0c 03 cmpl $0x3,0xc(%ebp) <== NOT EXECUTED 10dfa4: 76 0a jbe 10dfb0 <== NOT EXECUTED 10dfa6: b8 86 00 00 00 mov $0x86,%eax <== NOT EXECUTED return 0; default: return ENOTSUP; } } 10dfab: c9 leave <== NOT EXECUTED 10dfac: c3 ret <== NOT EXECUTED 10dfad: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED switch ( policy ) { case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; 10dfb0: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10dfb3: 89 50 14 mov %edx,0x14(%eax) <== NOT EXECUTED 10dfb6: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return ENOTSUP; } } 10dfb8: c9 leave <== NOT EXECUTED 10dfb9: c3 ret <== NOT EXECUTED 10dfba: 66 90 xchg %ax,%ax <== NOT EXECUTED case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: case SCHED_SPORADIC: attr->schedpolicy = policy; return 0; 10dfbc: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return ENOTSUP; } } 10dfc1: c9 leave <== NOT EXECUTED 10dfc2: c3 ret <== NOT EXECUTED 0010dfc4 : int pthread_attr_setscope( pthread_attr_t *attr, int contentionscope ) { 10dfc4: 55 push %ebp <== NOT EXECUTED 10dfc5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dfc7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10dfca: 85 c0 test %eax,%eax <== NOT EXECUTED 10dfcc: 74 20 je 10dfee <== NOT EXECUTED 10dfce: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10dfd0: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10dfd2: 74 1a je 10dfee <== NOT EXECUTED return EINVAL; switch ( contentionscope ) { 10dfd4: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10dfd7: 85 d2 test %edx,%edx <== NOT EXECUTED 10dfd9: 75 0d jne 10dfe8 <== NOT EXECUTED case PTHREAD_SCOPE_PROCESS: attr->contentionscope = contentionscope; 10dfdb: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED 10dfe2: 31 c0 xor %eax,%eax <== NOT EXECUTED return ENOTSUP; default: return EINVAL; } } 10dfe4: c9 leave <== NOT EXECUTED 10dfe5: c3 ret <== NOT EXECUTED 10dfe6: 66 90 xchg %ax,%ax <== NOT EXECUTED ) { if ( !attr || !attr->is_initialized ) return EINVAL; switch ( contentionscope ) { 10dfe8: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10dfec: 74 0a je 10dff8 <== NOT EXECUTED case PTHREAD_SCOPE_PROCESS: attr->contentionscope = contentionscope; return 0; 10dfee: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return ENOTSUP; default: return EINVAL; } } 10dff3: c9 leave <== NOT EXECUTED 10dff4: c3 ret <== NOT EXECUTED 10dff5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { if ( !attr || !attr->is_initialized ) return EINVAL; switch ( contentionscope ) { 10dff8: b8 86 00 00 00 mov $0x86,%eax <== NOT EXECUTED return ENOTSUP; default: return EINVAL; } } 10dffd: c9 leave <== NOT EXECUTED 10dffe: c3 ret <== NOT EXECUTED 0010e000 : int pthread_attr_setstackaddr( pthread_attr_t *attr, void *stackaddr ) { 10e000: 55 push %ebp <== NOT EXECUTED 10e001: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e003: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10e006: 85 c0 test %eax,%eax <== NOT EXECUTED 10e008: 74 12 je 10e01c <== NOT EXECUTED 10e00a: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10e00c: 85 d2 test %edx,%edx <== NOT EXECUTED 10e00e: 74 0c je 10e01c <== NOT EXECUTED return EINVAL; attr->stackaddr = stackaddr; 10e010: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10e013: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 10e016: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10e018: c9 leave <== NOT EXECUTED 10e019: c3 ret <== NOT EXECUTED 10e01a: 66 90 xchg %ax,%ax <== NOT EXECUTED { if ( !attr || !attr->is_initialized ) return EINVAL; attr->stackaddr = stackaddr; return 0; 10e01c: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10e021: c9 leave <== NOT EXECUTED 10e022: c3 ret <== NOT EXECUTED 00110ec4 : int pthread_attr_setstacksize( pthread_attr_t *attr, size_t stacksize ) { 110ec4: 55 push %ebp <== NOT EXECUTED 110ec5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110ec7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 110eca: 85 d2 test %edx,%edx <== NOT EXECUTED 110ecc: 74 1e je 110eec <== NOT EXECUTED 110ece: 8b 02 mov (%edx),%eax <== NOT EXECUTED 110ed0: 85 c0 test %eax,%eax <== NOT EXECUTED 110ed2: 74 18 je 110eec <== NOT EXECUTED return EINVAL; if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) 110ed4: a1 14 ee 11 00 mov 0x11ee14,%eax <== NOT EXECUTED 110ed9: d1 e0 shl %eax <== NOT EXECUTED 110edb: 3b 45 0c cmp 0xc(%ebp),%eax <== NOT EXECUTED 110ede: 77 03 ja 110ee3 <== NOT EXECUTED attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; else attr->stacksize = stacksize; 110ee0: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 110ee3: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED 110ee6: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 110ee8: c9 leave <== NOT EXECUTED 110ee9: c3 ret <== NOT EXECUTED 110eea: 66 90 xchg %ax,%ax <== NOT EXECUTED return EINVAL; if (stacksize < PTHREAD_MINIMUM_STACK_SIZE) attr->stacksize = PTHREAD_MINIMUM_STACK_SIZE; else attr->stacksize = stacksize; 110eec: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return 0; } 110ef1: c9 leave <== NOT EXECUTED 110ef2: c3 ret <== NOT EXECUTED 0010a400 : */ int pthread_barrier_destroy( pthread_barrier_t *barrier ) { 10a400: 55 push %ebp <== NOT EXECUTED 10a401: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a403: 53 push %ebx <== NOT EXECUTED 10a404: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10a407: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 10a40a: 85 d2 test %edx,%edx <== NOT EXECUTED 10a40c: 74 36 je 10a444 <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 10a40e: 50 push %eax <== NOT EXECUTED 10a40f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a412: 50 push %eax <== NOT EXECUTED 10a413: ff 32 pushl (%edx) <== NOT EXECUTED 10a415: 68 60 13 12 00 push $0x121360 <== NOT EXECUTED 10a41a: e8 a9 28 00 00 call 10ccc8 <_Objects_Get> <== NOT EXECUTED 10a41f: 89 c3 mov %eax,%ebx <== NOT EXECUTED return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 10a421: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a424: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10a427: 85 c0 test %eax,%eax <== NOT EXECUTED 10a429: 75 19 jne 10a444 <== NOT EXECUTED case OBJECTS_LOCAL: if ( the_barrier->Barrier.number_of_waiting_threads != 0 ) { 10a42b: 8b 4b 58 mov 0x58(%ebx),%ecx <== NOT EXECUTED 10a42e: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a430: 74 1e je 10a450 <== NOT EXECUTED _Thread_Enable_dispatch(); 10a432: e8 d5 30 00 00 call 10d50c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a437: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a43c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a43f: c9 leave <== NOT EXECUTED 10a440: c3 ret <== NOT EXECUTED 10a441: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Objects_Close( &_POSIX_Barrier_Information, &the_barrier->Object ); _POSIX_Barrier_Free( the_barrier ); _Thread_Enable_dispatch(); return 0; 10a444: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a449: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a44c: c9 leave <== NOT EXECUTED 10a44d: c3 ret <== NOT EXECUTED 10a44e: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( the_barrier->Barrier.number_of_waiting_threads != 0 ) { _Thread_Enable_dispatch(); return EBUSY; } _Objects_Close( &_POSIX_Barrier_Information, &the_barrier->Object ); 10a450: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a453: 53 push %ebx <== NOT EXECUTED 10a454: 68 60 13 12 00 push $0x121360 <== NOT EXECUTED 10a459: e8 f6 23 00 00 call 10c854 <_Objects_Close> <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * 10a45e: 58 pop %eax <== NOT EXECUTED 10a45f: 5a pop %edx <== NOT EXECUTED 10a460: 53 push %ebx <== NOT EXECUTED 10a461: 68 60 13 12 00 push $0x121360 <== NOT EXECUTED 10a466: e8 29 27 00 00 call 10cb94 <_Objects_Free> <== NOT EXECUTED _POSIX_Barrier_Free( the_barrier ); _Thread_Enable_dispatch(); 10a46b: e8 9c 30 00 00 call 10d50c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a470: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a472: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a475: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a478: c9 leave <== NOT EXECUTED 10a479: c3 ret <== NOT EXECUTED 0010a47c : int pthread_barrier_init( pthread_barrier_t *barrier, const pthread_barrierattr_t *attr, unsigned int count ) { 10a47c: 55 push %ebp <== NOT EXECUTED 10a47d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a47f: 57 push %edi <== NOT EXECUTED 10a480: 56 push %esi <== NOT EXECUTED 10a481: 53 push %ebx <== NOT EXECUTED 10a482: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10a485: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10a488: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED const pthread_barrierattr_t *the_attr; /* * Error check parameters */ if ( !barrier ) 10a48b: 85 ff test %edi,%edi <== NOT EXECUTED 10a48d: 0f 84 89 00 00 00 je 10a51c <== NOT EXECUTED return EINVAL; if ( count == 0 ) 10a493: 85 f6 test %esi,%esi <== NOT EXECUTED 10a495: 0f 84 81 00 00 00 je 10a51c <== NOT EXECUTED return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10a49b: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10a49e: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a4a0: 0f 84 92 00 00 00 je 10a538 <== NOT EXECUTED 10a4a6: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 10a4a9: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10a4ab: 85 d2 test %edx,%edx <== NOT EXECUTED 10a4ad: 74 6d je 10a51c <== NOT EXECUTED return EINVAL; switch ( the_attr->process_shared ) { 10a4af: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10a4b2: 85 c0 test %eax,%eax <== NOT EXECUTED 10a4b4: 75 66 jne 10a51c <== NOT EXECUTED } /* * Convert from POSIX attributes to Core Barrier attributes */ the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10a4b6: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) <== NOT EXECUTED the_attributes.maximum_count = count; 10a4bd: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a4c0: a1 18 0f 12 00 mov 0x120f18,%eax <== NOT EXECUTED 10a4c5: 40 inc %eax <== NOT EXECUTED 10a4c6: a3 18 0f 12 00 mov %eax,0x120f18 <== NOT EXECUTED */ /**@{*/ #ifdef __cplusplus extern "C" { #endif 10a4cb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a4ce: 68 60 13 12 00 push $0x121360 <== NOT EXECUTED 10a4d3: e8 fc 22 00 00 call 10c7d4 <_Objects_Allocate> <== NOT EXECUTED 10a4d8: 89 c3 mov %eax,%ebx <== NOT EXECUTED */ _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { 10a4da: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a4dd: 85 c0 test %eax,%eax <== NOT EXECUTED 10a4df: 74 4b je 10a52c <== NOT EXECUTED _Thread_Enable_dispatch(); return EAGAIN; } _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 10a4e1: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a4e4: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10a4e7: 50 push %eax <== NOT EXECUTED 10a4e8: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10a4eb: 50 push %eax <== NOT EXECUTED 10a4ec: e8 3f 1a 00 00 call 10bf30 <_CORE_barrier_Initialize> <== NOT EXECUTED 10a4f1: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10a4f4: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10a4f7: a1 7c 13 12 00 mov 0x12137c,%eax <== NOT EXECUTED 10a4fc: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10a4ff: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED ); /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; 10a506: 89 0f mov %ecx,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a508: e8 ff 2f 00 00 call 10d50c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a50d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a50f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10a512: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a515: 5b pop %ebx <== NOT EXECUTED 10a516: 5e pop %esi <== NOT EXECUTED 10a517: 5f pop %edi <== NOT EXECUTED 10a518: c9 leave <== NOT EXECUTED 10a519: c3 ret <== NOT EXECUTED 10a51a: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Exit the critical section and return the user an operational barrier */ *barrier = the_barrier->Object.id; _Thread_Enable_dispatch(); return 0; 10a51c: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10a521: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a524: 5b pop %ebx <== NOT EXECUTED 10a525: 5e pop %esi <== NOT EXECUTED 10a526: 5f pop %edi <== NOT EXECUTED 10a527: c9 leave <== NOT EXECUTED 10a528: c3 ret <== NOT EXECUTED 10a529: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _POSIX_Barrier_Allocate(); if ( !the_barrier ) { _Thread_Enable_dispatch(); 10a52c: e8 db 2f 00 00 call 10d50c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a531: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 10a536: eb e9 jmp 10a521 <== NOT EXECUTED * If the user passed in NULL, use the default attributes */ if ( attr ) { the_attr = attr; } else { (void) pthread_barrierattr_init( &my_attr ); 10a538: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a53b: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 10a53e: 53 push %ebx <== NOT EXECUTED 10a53f: e8 70 fe ff ff call 10a3b4 <== NOT EXECUTED 10a544: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a546: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a549: e9 5b ff ff ff jmp 10a4a9 <== NOT EXECUTED 0010a550 : */ int pthread_barrier_wait( pthread_barrier_t *barrier ) { 10a550: 55 push %ebp <== NOT EXECUTED 10a551: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a553: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10a556: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Barrier_Control *the_barrier = NULL; Objects_Locations location; if ( !barrier ) 10a559: 85 d2 test %edx,%edx <== NOT EXECUTED 10a55b: 74 4f je 10a5ac <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 10a55d: 51 push %ecx <== NOT EXECUTED 10a55e: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10a561: 50 push %eax <== NOT EXECUTED 10a562: ff 32 pushl (%edx) <== NOT EXECUTED 10a564: 68 60 13 12 00 push $0x121360 <== NOT EXECUTED 10a569: e8 5a 27 00 00 call 10ccc8 <_Objects_Get> <== NOT EXECUTED return EINVAL; the_barrier = _POSIX_Barrier_Get( barrier, &location ); switch ( location ) { 10a56e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a571: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10a574: 85 d2 test %edx,%edx <== NOT EXECUTED 10a576: 75 34 jne 10a5ac <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_barrier_Wait( 10a578: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a57b: 6a 00 push $0x0 <== NOT EXECUTED 10a57d: 6a 00 push $0x0 <== NOT EXECUTED 10a57f: 6a 01 push $0x1 <== NOT EXECUTED 10a581: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10a584: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10a587: 50 push %eax <== NOT EXECUTED 10a588: e8 d7 19 00 00 call 10bf64 <_CORE_barrier_Wait> <== NOT EXECUTED the_barrier->Object.id, TRUE, 0, NULL ); _Thread_Enable_dispatch(); 10a58d: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a590: e8 77 2f 00 00 call 10d50c <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_Barrier_Translate_core_barrier_return_code( 10a595: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a598: a1 dc 0f 12 00 mov 0x120fdc,%eax <== NOT EXECUTED 10a59d: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10a5a0: e8 4f 5c 00 00 call 1101f4 <_POSIX_Barrier_Translate_core_barrier_return_code> <== NOT EXECUTED 10a5a5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a5a8: c9 leave <== NOT EXECUTED 10a5a9: c3 ret <== NOT EXECUTED 10a5aa: 66 90 xchg %ax,%ax <== NOT EXECUTED TRUE, 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_Barrier_Translate_core_barrier_return_code( 10a5ac: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a5b1: c9 leave <== NOT EXECUTED 10a5b2: c3 ret <== NOT EXECUTED 0010a36c : */ int pthread_barrierattr_destroy( pthread_barrierattr_t *attr ) { 10a36c: 55 push %ebp <== NOT EXECUTED 10a36d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a36f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || attr->is_initialized == FALSE ) 10a372: 85 c0 test %eax,%eax <== NOT EXECUTED 10a374: 74 12 je 10a388 <== NOT EXECUTED 10a376: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10a378: 85 d2 test %edx,%edx <== NOT EXECUTED 10a37a: 74 0c je 10a388 <== NOT EXECUTED return EINVAL; attr->is_initialized = FALSE; 10a37c: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10a382: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10a384: c9 leave <== NOT EXECUTED 10a385: c3 ret <== NOT EXECUTED 10a386: 66 90 xchg %ax,%ax <== NOT EXECUTED { if ( !attr || attr->is_initialized == FALSE ) return EINVAL; attr->is_initialized = FALSE; return 0; 10a388: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10a38d: c9 leave <== NOT EXECUTED 10a38e: c3 ret <== NOT EXECUTED 0010a390 : int pthread_barrierattr_getpshared( const pthread_barrierattr_t *attr, int *pshared ) { 10a390: 55 push %ebp <== NOT EXECUTED 10a391: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a393: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10a396: 85 c0 test %eax,%eax <== NOT EXECUTED 10a398: 74 12 je 10a3ac <== NOT EXECUTED return EINVAL; if ( !attr->is_initialized ) 10a39a: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10a39c: 85 d2 test %edx,%edx <== NOT EXECUTED 10a39e: 74 0c je 10a3ac <== NOT EXECUTED return EINVAL; *pshared = attr->process_shared; 10a3a0: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10a3a3: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10a3a6: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10a3a8: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10a3aa: c9 leave <== NOT EXECUTED 10a3ab: c3 ret <== NOT EXECUTED if ( !attr->is_initialized ) return EINVAL; *pshared = attr->process_shared; return 0; 10a3ac: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10a3b1: c9 leave <== NOT EXECUTED 10a3b2: c3 ret <== NOT EXECUTED 0010a3b4 : */ int pthread_barrierattr_init( pthread_barrierattr_t *attr ) { 10a3b4: 55 push %ebp <== NOT EXECUTED 10a3b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a3b7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10a3ba: 85 c0 test %eax,%eax <== NOT EXECUTED 10a3bc: 74 12 je 10a3d0 <== NOT EXECUTED return EINVAL; attr->is_initialized = TRUE; 10a3be: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED attr->process_shared = PTHREAD_PROCESS_PRIVATE; 10a3c4: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED 10a3cb: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10a3cd: c9 leave <== NOT EXECUTED 10a3ce: c3 ret <== NOT EXECUTED 10a3cf: 90 nop <== NOT EXECUTED int pthread_barrierattr_init( pthread_barrierattr_t *attr ) { if ( !attr ) 10a3d0: b0 16 mov $0x16,%al <== NOT EXECUTED return EINVAL; attr->is_initialized = TRUE; attr->process_shared = PTHREAD_PROCESS_PRIVATE; return 0; } 10a3d2: c9 leave <== NOT EXECUTED 10a3d3: c3 ret <== NOT EXECUTED 0010a3d4 : int pthread_barrierattr_setpshared( pthread_barrierattr_t *attr, int pshared ) { 10a3d4: 55 push %ebp <== NOT EXECUTED 10a3d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a3d7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10a3da: 85 c0 test %eax,%eax <== NOT EXECUTED 10a3dc: 74 0c je 10a3ea <== NOT EXECUTED return EINVAL; if ( !attr->is_initialized ) 10a3de: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10a3e0: 85 d2 test %edx,%edx <== NOT EXECUTED 10a3e2: 74 06 je 10a3ea <== NOT EXECUTED return EINVAL; switch ( pshared ) { 10a3e4: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10a3e8: 76 0a jbe 10a3f4 <== NOT EXECUTED case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; return 0; 10a3ea: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10a3ef: c9 leave <== NOT EXECUTED 10a3f0: c3 ret <== NOT EXECUTED 10a3f1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return EINVAL; switch ( pshared ) { case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10a3f4: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10a3f7: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 10a3fa: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return EINVAL; } } 10a3fc: c9 leave <== NOT EXECUTED 10a3fd: c3 ret <== NOT EXECUTED 00109bac : */ int pthread_cancel( pthread_t thread ) { 109bac: 55 push %ebp <== NOT EXECUTED 109bad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109baf: 53 push %ebx <== NOT EXECUTED 109bb0: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED /* * Don't even think about deleting a resource from an ISR. */ if ( _ISR_Is_in_progress() ) 109bb3: a1 b8 22 12 00 mov 0x1222b8,%eax <== NOT EXECUTED 109bb8: 85 c0 test %eax,%eax <== NOT EXECUTED 109bba: 74 0c je 109bc8 <== NOT EXECUTED 109bbc: b8 47 00 00 00 mov $0x47,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 109bc1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109bc4: c9 leave <== NOT EXECUTED 109bc5: c3 ret <== NOT EXECUTED 109bc6: 66 90 xchg %ax,%ax <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 109bc8: 53 push %ebx <== NOT EXECUTED 109bc9: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109bcc: 50 push %eax <== NOT EXECUTED 109bcd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109bd0: 68 e0 24 12 00 push $0x1224e0 <== NOT EXECUTED 109bd5: e8 4e 29 00 00 call 10c528 <_Objects_Get> <== NOT EXECUTED 109bda: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( _ISR_Is_in_progress() ) return EPROTO; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 109bdc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109bdf: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 109be2: 85 c9 test %ecx,%ecx <== NOT EXECUTED 109be4: 74 0a je 109bf0 <== NOT EXECUTED 109be6: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 109beb: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109bee: c9 leave <== NOT EXECUTED 109bef: c3 ret <== NOT EXECUTED the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { case OBJECTS_LOCAL: thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ]; 109bf0: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED thread_support->cancelation_requested = 1; 109bf6: c7 80 d4 00 00 00 01 movl $0x1,0xd4(%eax) <== NOT EXECUTED 109bfd: 00 00 00 <== NOT EXECUTED if (thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 109c00: 8b 90 cc 00 00 00 mov 0xcc(%eax),%edx <== NOT EXECUTED 109c06: 85 d2 test %edx,%edx <== NOT EXECUTED 109c08: 75 09 jne 109c13 <== NOT EXECUTED 109c0a: 83 b8 d0 00 00 00 01 cmpl $0x1,0xd0(%eax) <== NOT EXECUTED 109c11: 74 0d je 109c20 <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS) cancel = true; _Thread_Enable_dispatch(); 109c13: e8 54 31 00 00 call 10cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED 109c18: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 109c1a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109c1d: c9 leave <== NOT EXECUTED 109c1e: c3 ret <== NOT EXECUTED 109c1f: 90 nop <== NOT EXECUTED if (thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS) cancel = true; _Thread_Enable_dispatch(); 109c20: e8 47 31 00 00 call 10cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED ); 109c25: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109c28: 6a ff push $0xffffffff <== NOT EXECUTED 109c2a: 53 push %ebx <== NOT EXECUTED 109c2b: e8 38 03 00 00 call 109f68 <_POSIX_Thread_Exit> <== NOT EXECUTED 109c30: 31 c0 xor %eax,%eax <== NOT EXECUTED 109c32: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109c35: eb 8a jmp 109bc1 <== NOT EXECUTED 0010a07c : */ void pthread_cleanup_pop( int execute ) { 10a07c: 55 push %ebp <== NOT EXECUTED 10a07d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a07f: 57 push %edi <== NOT EXECUTED 10a080: 56 push %esi <== NOT EXECUTED 10a081: 53 push %ebx <== NOT EXECUTED 10a082: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10a085: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a088: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED POSIX_Cancel_Handler_control tmp_handler; Chain_Control *handler_stack; POSIX_API_Control *thread_support; ISR_Level level; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a08b: a1 7c 2f 12 00 mov 0x122f7c,%eax <== NOT EXECUTED 10a090: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a096: a1 b8 2e 12 00 mov 0x122eb8,%eax <== NOT EXECUTED 10a09b: 40 inc %eax <== NOT EXECUTED 10a09c: a3 b8 2e 12 00 mov %eax,0x122eb8 <== NOT EXECUTED * ensure that we do not get prempted and deleted while we are holding * memory that needs to be freed. */ _Thread_Disable_dispatch(); _ISR_Disable( level ); 10a0a1: 9c pushf <== NOT EXECUTED 10a0a2: fa cli <== NOT EXECUTED 10a0a3: 5f pop %edi <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 10a0a4: 8d 82 dc 00 00 00 lea 0xdc(%edx),%eax <== NOT EXECUTED if ( _Chain_Is_empty( handler_stack ) ) { 10a0aa: 39 82 d8 00 00 00 cmp %eax,0xd8(%edx) <== NOT EXECUTED 10a0b0: 74 5a je 10a10c <== NOT EXECUTED _Thread_Enable_dispatch(); _ISR_Enable( level ); return; } handler = (POSIX_Cancel_Handler_control *) 10a0b2: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10a0b5: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED 10a0b8: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10a0ba: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10a0bd: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10a0c0: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Tail( handler_stack )->previous; _Chain_Extract_unprotected( &handler->Node ); _ISR_Enable( level ); 10a0c2: 57 push %edi <== NOT EXECUTED 10a0c3: 9d popf <== NOT EXECUTED tmp_handler = *handler; 10a0c4: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10a0c7: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10a0cc: 8b 75 d8 mov -0x28(%ebp),%esi <== NOT EXECUTED 10a0cf: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10a0d1: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 10a0d4: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED _Workspace_Free( handler ); 10a0d7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a0da: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 10a0dd: e8 9a 46 00 00 call 10e77c <_Workspace_Free> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a0e2: e8 d9 34 00 00 call 10d5c0 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( execute ) 10a0e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0ea: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10a0ed: 85 c0 test %eax,%eax <== NOT EXECUTED 10a0ef: 75 0b jne 10a0fc <== NOT EXECUTED (*tmp_handler.routine)( tmp_handler.arg ); } 10a0f1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a0f4: 5b pop %ebx <== NOT EXECUTED 10a0f5: 5e pop %esi <== NOT EXECUTED 10a0f6: 5f pop %edi <== NOT EXECUTED 10a0f7: c9 leave <== NOT EXECUTED 10a0f8: c3 ret <== NOT EXECUTED 10a0f9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Workspace_Free( handler ); _Thread_Enable_dispatch(); if ( execute ) (*tmp_handler.routine)( tmp_handler.arg ); 10a0fc: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED 10a0ff: 89 d9 mov %ebx,%ecx <== NOT EXECUTED } 10a101: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a104: 5b pop %ebx <== NOT EXECUTED 10a105: 5e pop %esi <== NOT EXECUTED 10a106: 5f pop %edi <== NOT EXECUTED 10a107: c9 leave <== NOT EXECUTED _Workspace_Free( handler ); _Thread_Enable_dispatch(); if ( execute ) (*tmp_handler.routine)( tmp_handler.arg ); 10a108: ff e1 jmp *%ecx <== NOT EXECUTED 10a10a: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_Disable_dispatch(); _ISR_Disable( level ); if ( _Chain_Is_empty( handler_stack ) ) { _Thread_Enable_dispatch(); 10a10c: e8 af 34 00 00 call 10d5c0 <_Thread_Enable_dispatch> <== NOT EXECUTED _ISR_Enable( level ); 10a111: 57 push %edi <== NOT EXECUTED 10a112: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); if ( execute ) (*tmp_handler.routine)( tmp_handler.arg ); } 10a113: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a116: 5b pop %ebx <== NOT EXECUTED 10a117: 5e pop %esi <== NOT EXECUTED 10a118: 5f pop %edi <== NOT EXECUTED 10a119: c9 leave <== NOT EXECUTED 10a11a: c3 ret <== NOT EXECUTED 0010a11c : void pthread_cleanup_push( void (*routine)( void * ), void *arg ) { 10a11c: 55 push %ebp <== NOT EXECUTED 10a11d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a11f: 56 push %esi <== NOT EXECUTED 10a120: 53 push %ebx <== NOT EXECUTED 10a121: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a124: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * The POSIX standard does not address what to do when the routine * is NULL. It also does not address what happens when we cannot * allocate memory or anything else bad happens. */ if ( !routine ) 10a127: 85 db test %ebx,%ebx <== NOT EXECUTED 10a129: 74 4d je 10a178 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a12b: a1 b8 2e 12 00 mov 0x122eb8,%eax <== NOT EXECUTED 10a130: 40 inc %eax <== NOT EXECUTED 10a131: a3 b8 2e 12 00 mov %eax,0x122eb8 <== NOT EXECUTED return; _Thread_Disable_dispatch(); handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) ); 10a136: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a139: 6a 10 push $0x10 <== NOT EXECUTED 10a13b: e8 54 46 00 00 call 10e794 <_Workspace_Allocate> <== NOT EXECUTED 10a140: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( handler ) { 10a142: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a145: 85 c0 test %eax,%eax <== NOT EXECUTED 10a147: 74 23 je 10a16c <== NOT EXECUTED thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; handler_stack = &thread_support->Cancellation_Handlers; 10a149: a1 7c 2f 12 00 mov 0x122f7c,%eax <== NOT EXECUTED 10a14e: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED 10a154: 05 d8 00 00 00 add $0xd8,%eax <== NOT EXECUTED handler->routine = routine; 10a159: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED handler->arg = arg; 10a15c: 89 72 0c mov %esi,0xc(%edx) <== NOT EXECUTED _Chain_Append( handler_stack, &handler->Node ); 10a15f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a162: 52 push %edx <== NOT EXECUTED 10a163: 50 push %eax <== NOT EXECUTED 10a164: e8 e7 1e 00 00 call 10c050 <_Chain_Append> <== NOT EXECUTED 10a169: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _Thread_Enable_dispatch(); } 10a16c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a16f: 5b pop %ebx <== NOT EXECUTED 10a170: 5e pop %esi <== NOT EXECUTED 10a171: c9 leave <== NOT EXECUTED handler->routine = routine; handler->arg = arg; _Chain_Append( handler_stack, &handler->Node ); } _Thread_Enable_dispatch(); 10a172: e9 49 34 00 00 jmp 10d5c0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a177: 90 nop <== NOT EXECUTED } 10a178: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a17b: 5b pop %ebx <== NOT EXECUTED 10a17c: 5e pop %esi <== NOT EXECUTED 10a17d: c9 leave <== NOT EXECUTED 10a17e: c3 ret <== NOT EXECUTED 0010ad44 : */ int pthread_cond_broadcast( pthread_cond_t *cond ) { 10ad44: 55 push %ebp <== NOT EXECUTED 10ad45: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad47: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _POSIX_Condition_variables_Signal_support( cond, TRUE ); 10ad4a: 6a 01 push $0x1 <== NOT EXECUTED 10ad4c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ad4f: e8 98 01 00 00 call 10aeec <_POSIX_Condition_variables_Signal_support> <== NOT EXECUTED } 10ad54: c9 leave <== NOT EXECUTED 10ad55: c3 ret <== NOT EXECUTED 0010ad58 : */ int pthread_cond_destroy( pthread_cond_t *cond ) { 10ad58: 55 push %ebp <== NOT EXECUTED 10ad59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad5b: 53 push %ebx <== NOT EXECUTED 10ad5c: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED POSIX_Condition_variables_Control *the_cond; Objects_Locations location; the_cond = _POSIX_Condition_variables_Get( cond, &location ); 10ad5f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10ad62: 50 push %eax <== NOT EXECUTED 10ad63: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ad66: e8 65 00 00 00 call 10add0 <_POSIX_Condition_variables_Get> <== NOT EXECUTED 10ad6b: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch ( location ) { 10ad6d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad70: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 10ad73: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ad75: 75 25 jne 10ad9c <== NOT EXECUTED case OBJECTS_LOCAL: if ( _Thread_queue_First( &the_cond->Wait_queue ) ) { 10ad77: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad7a: 8d 40 18 lea 0x18(%eax),%eax <== NOT EXECUTED 10ad7d: 50 push %eax <== NOT EXECUTED 10ad7e: e8 89 3d 00 00 call 10eb0c <_Thread_queue_First> <== NOT EXECUTED 10ad83: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad86: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad88: 74 1e je 10ada8 <== NOT EXECUTED _Thread_Enable_dispatch(); 10ad8a: e8 75 36 00 00 call 10e404 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ad8f: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ad94: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ad97: c9 leave <== NOT EXECUTED 10ad98: c3 ret <== NOT EXECUTED 10ad99: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { POSIX_Condition_variables_Control *the_cond; Objects_Locations location; the_cond = _POSIX_Condition_variables_Get( cond, &location ); switch ( location ) { 10ad9c: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ada1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ada4: c9 leave <== NOT EXECUTED 10ada5: c3 ret <== NOT EXECUTED 10ada6: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( _Thread_queue_First( &the_cond->Wait_queue ) ) { _Thread_Enable_dispatch(); return EBUSY; } _Objects_Close( 10ada8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10adab: 53 push %ebx <== NOT EXECUTED 10adac: 68 00 2c 12 00 push $0x122c00 <== NOT EXECUTED 10adb1: e8 96 29 00 00 call 10d74c <_Objects_Close> <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * 10adb6: 58 pop %eax <== NOT EXECUTED 10adb7: 5a pop %edx <== NOT EXECUTED 10adb8: 53 push %ebx <== NOT EXECUTED 10adb9: 68 00 2c 12 00 push $0x122c00 <== NOT EXECUTED 10adbe: e8 c9 2c 00 00 call 10da8c <_Objects_Free> <== NOT EXECUTED &_POSIX_Condition_variables_Information, &the_cond->Object ); _POSIX_Condition_variables_Free( the_cond ); _Thread_Enable_dispatch(); 10adc3: e8 3c 36 00 00 call 10e404 <_Thread_Enable_dispatch> <== NOT EXECUTED 10adc8: 31 c0 xor %eax,%eax <== NOT EXECUTED 10adca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10adcd: eb d2 jmp 10ada1 <== NOT EXECUTED 0010ae24 : int pthread_cond_init( pthread_cond_t *cond, const pthread_condattr_t *attr ) { 10ae24: 55 push %ebp <== NOT EXECUTED 10ae25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae27: 56 push %esi <== NOT EXECUTED 10ae28: 53 push %ebx <== NOT EXECUTED 10ae29: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 10ae2c: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae2e: 0f 84 88 00 00 00 je 10aebc <== NOT EXECUTED 10ae34: 89 c3 mov %eax,%ebx <== NOT EXECUTED /* * Be careful about attributes when global!!! */ if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED ) 10ae36: 83 7b 04 01 cmpl $0x1,0x4(%ebx) <== NOT EXECUTED 10ae3a: 74 06 je 10ae42 <== NOT EXECUTED return EINVAL; if ( !the_attr->is_initialized ) 10ae3c: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10ae3e: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae40: 75 0e jne 10ae50 <== NOT EXECUTED *cond = the_cond->Object.id; _Thread_Enable_dispatch(); return 0; 10ae42: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10ae47: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ae4a: 5b pop %ebx <== NOT EXECUTED 10ae4b: 5e pop %esi <== NOT EXECUTED 10ae4c: c9 leave <== NOT EXECUTED 10ae4d: c3 ret <== NOT EXECUTED 10ae4e: 66 90 xchg %ax,%ax <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10ae50: a1 18 27 12 00 mov 0x122718,%eax <== NOT EXECUTED 10ae55: 40 inc %eax <== NOT EXECUTED 10ae56: a3 18 27 12 00 mov %eax,0x122718 <== NOT EXECUTED /**@{*/ #ifdef __cplusplus extern "C" { #endif 10ae5b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae5e: 68 00 2c 12 00 push $0x122c00 <== NOT EXECUTED 10ae63: e8 64 28 00 00 call 10d6cc <_Objects_Allocate> <== NOT EXECUTED 10ae68: 89 c6 mov %eax,%esi <== NOT EXECUTED _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { 10ae6a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae6d: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae6f: 74 57 je 10aec8 <== NOT EXECUTED _Thread_Enable_dispatch(); return ENOMEM; } the_cond->process_shared = the_attr->process_shared; 10ae71: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10ae74: 89 46 10 mov %eax,0x10(%esi) <== NOT EXECUTED the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX; 10ae77: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED /* XXX some more initialization might need to go here */ _Thread_queue_Initialize( 10ae7e: 6a 74 push $0x74 <== NOT EXECUTED 10ae80: 68 00 08 00 00 push $0x800 <== NOT EXECUTED 10ae85: 6a 00 push $0x0 <== NOT EXECUTED 10ae87: 8d 46 18 lea 0x18(%esi),%eax <== NOT EXECUTED 10ae8a: 50 push %eax <== NOT EXECUTED 10ae8b: e8 00 3d 00 00 call 10eb90 <_Thread_queue_Initialize> <== NOT EXECUTED 10ae90: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED 10ae93: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10ae96: a1 1c 2c 12 00 mov 0x122c1c,%eax <== NOT EXECUTED 10ae9b: 89 34 90 mov %esi,(%eax,%edx,4) <== NOT EXECUTED 10ae9e: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) <== NOT EXECUTED &_POSIX_Condition_variables_Information, &the_cond->Object, 0 ); *cond = the_cond->Object.id; 10aea5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10aea8: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10aeaa: e8 55 35 00 00 call 10e404 <_Thread_Enable_dispatch> <== NOT EXECUTED 10aeaf: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aeb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10aeb4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10aeb7: 5b pop %ebx <== NOT EXECUTED 10aeb8: 5e pop %esi <== NOT EXECUTED 10aeb9: c9 leave <== NOT EXECUTED 10aeba: c3 ret <== NOT EXECUTED 10aebb: 90 nop <== NOT EXECUTED ) { POSIX_Condition_variables_Control *the_cond; const pthread_condattr_t *the_attr; if ( attr ) the_attr = attr; 10aebc: bb 48 ca 11 00 mov $0x11ca48,%ebx <== NOT EXECUTED 10aec1: e9 70 ff ff ff jmp 10ae36 <== NOT EXECUTED 10aec6: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_Disable_dispatch(); the_cond = _POSIX_Condition_variables_Allocate(); if ( !the_cond ) { _Thread_Enable_dispatch(); 10aec8: e8 37 35 00 00 call 10e404 <_Thread_Enable_dispatch> <== NOT EXECUTED 10aecd: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED 10aed2: e9 70 ff ff ff jmp 10ae47 <== NOT EXECUTED 0010aed8 : */ int pthread_cond_signal( pthread_cond_t *cond ) { 10aed8: 55 push %ebp <== NOT EXECUTED 10aed9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aedb: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _POSIX_Condition_variables_Signal_support( cond, FALSE ); 10aede: 6a 00 push $0x0 <== NOT EXECUTED 10aee0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10aee3: e8 04 00 00 00 call 10aeec <_POSIX_Condition_variables_Signal_support> <== NOT EXECUTED } 10aee8: c9 leave <== NOT EXECUTED 10aee9: c3 ret <== NOT EXECUTED 0010af60 : int pthread_cond_timedwait( pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime ) { 10af60: 55 push %ebp <== NOT EXECUTED 10af61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10af63: 53 push %ebx <== NOT EXECUTED 10af64: 83 ec 1c sub $0x1c,%esp <== 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) ) { 10af67: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10af6a: 50 push %eax <== NOT EXECUTED 10af6b: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10af6e: e8 8d 04 00 00 call 10b400 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 10af73: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af76: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10af79: 77 21 ja 10af9c <== NOT EXECUTED 10af7b: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10af7e: 72 28 jb 10afa8 <== NOT EXECUTED 10af80: b3 01 mov $0x1,%bl <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: already_timedout = FALSE; break; } return _POSIX_Condition_variables_Wait_support( 10af82: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10af85: 50 push %eax <== NOT EXECUTED 10af86: ff 75 f8 pushl -0x8(%ebp) <== NOT EXECUTED 10af89: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10af8c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10af8f: e8 38 00 00 00 call 10afcc <_POSIX_Condition_variables_Wait_support> <== NOT EXECUTED 10af94: 83 c4 10 add $0x10,%esp <== NOT EXECUTED cond, mutex, ticks, already_timedout ); } 10af97: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10af9a: c9 leave <== NOT EXECUTED 10af9b: c3 ret <== 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) ) { 10af9c: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10af9f: 75 e1 jne 10af82 <== NOT EXECUTED 10afa1: 31 db xor %ebx,%ebx <== NOT EXECUTED 10afa3: eb dd jmp 10af82 <== NOT EXECUTED 10afa5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10afa8: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED cond, mutex, ticks, already_timedout ); } 10afad: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10afb0: c9 leave <== NOT EXECUTED 10afb1: c3 ret <== NOT EXECUTED 0010afb4 : int pthread_cond_wait( pthread_cond_t *cond, pthread_mutex_t *mutex ) { 10afb4: 55 push %ebp <== NOT EXECUTED 10afb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10afb7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED return _POSIX_Condition_variables_Wait_support( 10afba: 6a 00 push $0x0 <== NOT EXECUTED 10afbc: 6a 00 push $0x0 <== NOT EXECUTED 10afbe: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10afc1: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10afc4: e8 03 00 00 00 call 10afcc <_POSIX_Condition_variables_Wait_support> <== NOT EXECUTED cond, mutex, THREAD_QUEUE_WAIT_FOREVER, FALSE ); } 10afc9: c9 leave <== NOT EXECUTED 10afca: c3 ret <== NOT EXECUTED 0010acb8 : */ int pthread_condattr_destroy( pthread_condattr_t *attr ) { 10acb8: 55 push %ebp <== NOT EXECUTED 10acb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10acbb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || attr->is_initialized == FALSE ) 10acbe: 85 c0 test %eax,%eax <== NOT EXECUTED 10acc0: 74 12 je 10acd4 <== NOT EXECUTED 10acc2: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10acc4: 85 d2 test %edx,%edx <== NOT EXECUTED 10acc6: 74 0c je 10acd4 <== NOT EXECUTED return EINVAL; attr->is_initialized = FALSE; 10acc8: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10acce: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10acd0: c9 leave <== NOT EXECUTED 10acd1: c3 ret <== NOT EXECUTED 10acd2: 66 90 xchg %ax,%ax <== NOT EXECUTED { if ( !attr || attr->is_initialized == FALSE ) return EINVAL; attr->is_initialized = FALSE; return 0; 10acd4: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10acd9: c9 leave <== NOT EXECUTED 10acda: c3 ret <== NOT EXECUTED 0010acdc : int pthread_condattr_getpshared( const pthread_condattr_t *attr, int *pshared ) { 10acdc: 55 push %ebp <== NOT EXECUTED 10acdd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10acdf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10ace2: 85 c0 test %eax,%eax <== NOT EXECUTED 10ace4: 74 0e je 10acf4 <== NOT EXECUTED return EINVAL; *pshared = attr->process_shared; 10ace6: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10ace9: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10acec: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10acee: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10acf0: c9 leave <== NOT EXECUTED 10acf1: c3 ret <== NOT EXECUTED 10acf2: 66 90 xchg %ax,%ax <== NOT EXECUTED int pthread_condattr_getpshared( const pthread_condattr_t *attr, int *pshared ) { if ( !attr ) 10acf4: b0 16 mov $0x16,%al <== NOT EXECUTED return EINVAL; *pshared = attr->process_shared; return 0; } 10acf6: c9 leave <== NOT EXECUTED 10acf7: c3 ret <== NOT EXECUTED 0010acf8 : */ int pthread_condattr_init( pthread_condattr_t *attr ) { 10acf8: 55 push %ebp <== NOT EXECUTED 10acf9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10acfb: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED if ( !attr ) 10acfe: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ad00: 74 16 je 10ad18 <== NOT EXECUTED return EINVAL; *attr = _POSIX_Condition_variables_Default_attributes; 10ad02: a1 48 ca 11 00 mov 0x11ca48,%eax <== NOT EXECUTED 10ad07: 8b 15 4c ca 11 00 mov 0x11ca4c,%edx <== NOT EXECUTED 10ad0d: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10ad0f: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED 10ad12: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10ad14: c9 leave <== NOT EXECUTED 10ad15: c3 ret <== NOT EXECUTED 10ad16: 66 90 xchg %ax,%ax <== NOT EXECUTED int pthread_condattr_init( pthread_condattr_t *attr ) { if ( !attr ) 10ad18: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return EINVAL; *attr = _POSIX_Condition_variables_Default_attributes; return 0; } 10ad1d: c9 leave <== NOT EXECUTED 10ad1e: c3 ret <== NOT EXECUTED 0010ad20 : int pthread_condattr_setpshared( pthread_condattr_t *attr, int pshared ) { 10ad20: 55 push %ebp <== NOT EXECUTED 10ad21: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad23: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10ad26: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad28: 74 06 je 10ad30 <== NOT EXECUTED return EINVAL; switch ( pshared ) { 10ad2a: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10ad2e: 76 08 jbe 10ad38 <== NOT EXECUTED case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; return 0; 10ad30: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10ad35: c9 leave <== NOT EXECUTED 10ad36: c3 ret <== NOT EXECUTED 10ad37: 90 nop <== NOT EXECUTED return EINVAL; switch ( pshared ) { case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10ad38: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10ad3b: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 10ad3e: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return EINVAL; } } 10ad40: c9 leave <== NOT EXECUTED 10ad41: c3 ret <== NOT EXECUTED 0010aca4 : pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)( void * ), void *arg ) { 10aca4: 55 push %ebp <== NOT EXECUTED 10aca5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aca7: 57 push %edi <== NOT EXECUTED 10aca8: 56 push %esi <== NOT EXECUTED 10aca9: 53 push %ebx <== NOT EXECUTED 10acaa: 83 ec 5c sub $0x5c,%esp <== NOT EXECUTED 10acad: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED POSIX_API_Control *api; int schedpolicy = SCHED_RR; struct sched_param schedparam; Objects_Name name; if ( !start_routine ) 10acb0: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10acb3: 85 db test %ebx,%ebx <== NOT EXECUTED 10acb5: 0f 84 b9 01 00 00 je 10ae74 <== NOT EXECUTED return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 10acbb: 85 f6 test %esi,%esi <== NOT EXECUTED 10acbd: 0f 84 7d 01 00 00 je 10ae40 <== NOT EXECUTED 10acc3: 89 75 a4 mov %esi,-0x5c(%ebp) <== NOT EXECUTED if ( !the_attr->is_initialized ) 10acc6: 8b 45 a4 mov -0x5c(%ebp),%eax <== NOT EXECUTED 10acc9: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10accb: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10accd: 74 29 je 10acf8 <== NOT EXECUTED * stack space if it is allowed to allocate it itself. * * NOTE: If the user provides the stack we will let it drop below * twice the minimum. */ if ( the_attr->stackaddr && !_Stack_Is_enough(the_attr->stacksize) ) 10accf: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 10acd2: 85 d2 test %edx,%edx <== NOT EXECUTED 10acd4: 74 0b je 10ace1 <== NOT EXECUTED 10acd6: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10acd9: 3b 05 14 ee 11 00 cmp 0x11ee14,%eax <== NOT EXECUTED 10acdf: 72 17 jb 10acf8 <== NOT EXECUTED * 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 ) { 10ace1: 8b 75 a4 mov -0x5c(%ebp),%esi <== NOT EXECUTED 10ace4: 8b 46 10 mov 0x10(%esi),%eax <== NOT EXECUTED 10ace7: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10acea: 0f 84 5c 01 00 00 je 10ae4c <== NOT EXECUTED 10acf0: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10acf3: 74 13 je 10ad08 <== NOT EXECUTED 10acf5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ *thread = the_thread->Object.id; _RTEMS_Unlock_allocator(); return 0; 10acf8: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10acfd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ad00: 5b pop %ebx <== NOT EXECUTED 10ad01: 5e pop %esi <== NOT EXECUTED 10ad02: 5f pop %edi <== NOT EXECUTED 10ad03: c9 leave <== NOT EXECUTED 10ad04: c3 ret <== NOT EXECUTED 10ad05: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED schedpolicy = api->schedpolicy; schedparam = api->schedparam; break; case PTHREAD_EXPLICIT_SCHED: schedpolicy = the_attr->schedpolicy; 10ad08: 8b 45 a4 mov -0x5c(%ebp),%eax <== NOT EXECUTED 10ad0b: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10ad0e: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED schedparam = the_attr->schedparam; 10ad11: 8d 5d dc lea -0x24(%ebp),%ebx <== NOT EXECUTED 10ad14: 8b 75 a4 mov -0x5c(%ebp),%esi <== NOT EXECUTED 10ad17: 83 c6 18 add $0x18,%esi <== NOT EXECUTED 10ad1a: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10ad1f: 89 df mov %ebx,%edi <== NOT EXECUTED 10ad21: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 10ad23: 8b 45 a4 mov -0x5c(%ebp),%eax <== NOT EXECUTED 10ad26: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10ad29: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad2b: 0f 85 4f 01 00 00 jne 10ae80 <== NOT EXECUTED /* * Interpret the scheduling parameters. */ if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) ) 10ad31: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10ad34: 89 55 c0 mov %edx,-0x40(%ebp) <== NOT EXECUTED 10ad37: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ad39: 48 dec %eax <== NOT EXECUTED 10ad3a: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10ad3f: 77 b7 ja 10acf8 <== NOT EXECUTED */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 10ad41: 83 7d cc 01 cmpl $0x1,-0x34(%ebp) <== NOT EXECUTED 10ad45: 0f 84 55 01 00 00 je 10aea0 <== NOT EXECUTED 10ad4b: 0f 8e ef 01 00 00 jle 10af40 <== NOT EXECUTED 10ad51: 83 7d cc 02 cmpl $0x2,-0x34(%ebp) <== NOT EXECUTED 10ad55: 0f 84 31 01 00 00 je 10ae8c <== NOT EXECUTED 10ad5b: 83 7d cc 03 cmpl $0x3,-0x34(%ebp) <== NOT EXECUTED 10ad5f: 75 97 jne 10acf8 <== NOT EXECUTED 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 ) < 10ad61: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad64: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10ad67: 50 push %eax <== NOT EXECUTED 10ad68: e8 ab 3f 00 00 call 10ed18 <_Timespec_To_ticks> <== NOT EXECUTED 10ad6d: 89 c6 mov %eax,%esi <== NOT EXECUTED 10ad6f: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10ad72: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10ad75: e8 9e 3f 00 00 call 10ed18 <_Timespec_To_ticks> <== NOT EXECUTED 10ad7a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad7d: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10ad7f: 0f 82 73 ff ff ff jb 10acf8 <== NOT EXECUTED _Timespec_To_ticks( &schedparam.ss_initial_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( schedparam.ss_low_priority ) ) 10ad85: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10ad88: 48 dec %eax <== NOT EXECUTED 10ad89: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10ad8e: 0f 87 64 ff ff ff ja 10acf8 <== NOT EXECUTED 10ad94: c7 45 c4 03 00 00 00 movl $0x3,-0x3c(%ebp) <== NOT EXECUTED 10ad9b: c7 45 c8 20 b3 10 00 movl $0x10b320,-0x38(%ebp) <== NOT EXECUTED 10ada2: 66 90 xchg %ax,%ax <== NOT EXECUTED #endif /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10ada4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ada7: ff 35 74 34 12 00 pushl 0x123474 <== NOT EXECUTED 10adad: e8 82 1b 00 00 call 10c934 <_API_Mutex_Lock> <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 10adb2: c7 04 24 80 36 12 00 movl $0x123680,(%esp) <== NOT EXECUTED 10adb9: e8 e2 24 00 00 call 10d2a0 <_Objects_Allocate> <== NOT EXECUTED 10adbe: 89 45 a8 mov %eax,-0x58(%ebp) <== NOT EXECUTED * NOTE: Global threads are not currently supported. */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { 10adc1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10adc4: 85 c0 test %eax,%eax <== NOT EXECUTED 10adc6: 0f 84 92 01 00 00 je 10af5e <== NOT EXECUTED /* * Initialize the core thread for this task. */ name.name_p = NULL; /* posix threads don't have a name by default */ status = _Thread_Initialize( 10adcc: 8b 75 a4 mov -0x5c(%ebp),%esi <== NOT EXECUTED 10adcf: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED 10add2: 50 push %eax <== NOT EXECUTED 10add3: 6a 00 push $0x0 <== NOT EXECUTED 10add5: 6a 00 push $0x0 <== NOT EXECUTED 10add7: ff 75 c8 pushl -0x38(%ebp) <== NOT EXECUTED 10adda: ff 75 c4 pushl -0x3c(%ebp) <== NOT EXECUTED 10addd: 6a 01 push $0x1 <== NOT EXECUTED 10addf: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10ade4: 2b 45 c0 sub -0x40(%ebp),%eax <== NOT EXECUTED 10ade7: 50 push %eax <== NOT EXECUTED 10ade8: 6a 01 push $0x1 <== NOT EXECUTED 10adea: a1 14 ee 11 00 mov 0x11ee14,%eax <== NOT EXECUTED 10adef: d1 e0 shl %eax <== NOT EXECUTED 10adf1: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10adf3: 73 02 jae 10adf7 <== NOT EXECUTED 10adf5: 89 d0 mov %edx,%eax <== NOT EXECUTED 10adf7: 50 push %eax <== NOT EXECUTED 10adf8: 8b 7d a4 mov -0x5c(%ebp),%edi <== NOT EXECUTED 10adfb: ff 77 04 pushl 0x4(%edi) <== NOT EXECUTED 10adfe: ff 75 a8 pushl -0x58(%ebp) <== NOT EXECUTED 10ae01: 68 80 36 12 00 push $0x123680 <== NOT EXECUTED 10ae06: e8 9d 32 00 00 call 10e0a8 <_Thread_Initialize> <== NOT EXECUTED budget_callout, 0, /* isr level */ name /* posix threads don't have a name */ ); if ( !status ) { 10ae0b: 83 c4 30 add $0x30,%esp <== NOT EXECUTED 10ae0e: 84 c0 test %al,%al <== NOT EXECUTED 10ae10: 0f 85 9e 00 00 00 jne 10aeb4 <== NOT EXECUTED * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 10ae16: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ae19: ff 75 a8 pushl -0x58(%ebp) <== NOT EXECUTED 10ae1c: 68 80 36 12 00 push $0x123680 <== NOT EXECUTED 10ae21: e8 3a 28 00 00 call 10d660 <_Objects_Free> <== NOT EXECUTED _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 10ae26: 5f pop %edi <== NOT EXECUTED 10ae27: ff 35 74 34 12 00 pushl 0x123474 <== NOT EXECUTED 10ae2d: e8 4a 1b 00 00 call 10c97c <_API_Mutex_Unlock> <== NOT EXECUTED 10ae32: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 10ae37: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae3a: e9 be fe ff ff jmp 10acfd <== NOT EXECUTED 10ae3f: 90 nop <== NOT EXECUTED Objects_Name name; if ( !start_routine ) return EFAULT; the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes; 10ae40: c7 45 a4 a0 c9 11 00 movl $0x11c9a0,-0x5c(%ebp) <== NOT EXECUTED 10ae47: e9 7a fe ff ff jmp 10acc6 <== NOT EXECUTED * attributes structure. */ switch ( the_attr->inheritsched ) { case PTHREAD_INHERIT_SCHED: api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10ae4c: a1 7c 34 12 00 mov 0x12347c,%eax <== NOT EXECUTED 10ae51: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED schedpolicy = api->schedpolicy; 10ae57: 8b 78 7c mov 0x7c(%eax),%edi <== NOT EXECUTED 10ae5a: 89 7d cc mov %edi,-0x34(%ebp) <== NOT EXECUTED schedparam = api->schedparam; 10ae5d: 8d 5d dc lea -0x24(%ebp),%ebx <== NOT EXECUTED 10ae60: 8d b0 80 00 00 00 lea 0x80(%eax),%esi <== NOT EXECUTED 10ae66: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10ae6b: 89 df mov %ebx,%edi <== NOT EXECUTED 10ae6d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10ae6f: e9 af fe ff ff jmp 10ad23 <== NOT EXECUTED POSIX_API_Control *api; int schedpolicy = SCHED_RR; struct sched_param schedparam; Objects_Name name; if ( !start_routine ) 10ae74: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 10ae79: e9 7f fe ff ff jmp 10acfd <== NOT EXECUTED 10ae7e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Check the contentionscope since rtems only supports PROCESS wide * contention (i.e. no system wide contention). */ if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS ) 10ae80: b8 86 00 00 00 mov $0x86,%eax <== NOT EXECUTED 10ae85: e9 73 fe ff ff jmp 10acfd <== NOT EXECUTED 10ae8a: 66 90 xchg %ax,%ax <== NOT EXECUTED */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 10ae8c: c7 45 c4 02 00 00 00 movl $0x2,-0x3c(%ebp) <== NOT EXECUTED 10ae93: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) <== NOT EXECUTED 10ae9a: e9 05 ff ff ff jmp 10ada4 <== NOT EXECUTED 10ae9f: 90 nop <== NOT EXECUTED 10aea0: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp) <== NOT EXECUTED 10aea7: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) <== NOT EXECUTED 10aeae: e9 f1 fe ff ff jmp 10ada4 <== NOT EXECUTED 10aeb3: 90 nop <== NOT EXECUTED /* * finish initializing the per API structure */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10aeb4: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 10aeb7: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED 10aebd: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED api->Attributes = *the_attr; 10aec0: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 10aec5: 89 c7 mov %eax,%edi <== NOT EXECUTED 10aec7: 8b 75 a4 mov -0x5c(%ebp),%esi <== NOT EXECUTED 10aeca: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED api->detachstate = the_attr->detachstate; 10aecc: 8b 55 a4 mov -0x5c(%ebp),%edx <== NOT EXECUTED 10aecf: 8b 42 34 mov 0x34(%edx),%eax <== NOT EXECUTED 10aed2: 8b 75 d0 mov -0x30(%ebp),%esi <== NOT EXECUTED 10aed5: 89 46 38 mov %eax,0x38(%esi) <== NOT EXECUTED api->schedpolicy = schedpolicy; 10aed8: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED 10aedb: 89 7e 7c mov %edi,0x7c(%esi) <== NOT EXECUTED api->schedparam = schedparam; 10aede: 89 f7 mov %esi,%edi <== NOT EXECUTED 10aee0: 83 ef 80 sub $0xffffff80,%edi <== NOT EXECUTED 10aee3: b1 06 mov $0x6,%cl <== NOT EXECUTED 10aee5: 89 de mov %ebx,%esi <== NOT EXECUTED 10aee7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED * first run. * * NOTE: Since the thread starts with all unblocked, this is necessary. */ the_thread->do_post_task_switch_extension = true; 10aee9: 8b 7d a8 mov -0x58(%ebp),%edi <== NOT EXECUTED 10aeec: c6 47 75 01 movb $0x1,0x75(%edi) <== NOT EXECUTED /* * POSIX threads are allocated and started in one operation. */ status = _Thread_Start( 10aef0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aef3: 6a 00 push $0x0 <== NOT EXECUTED 10aef5: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10aef8: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10aefb: 6a 01 push $0x1 <== NOT EXECUTED 10aefd: 57 push %edi <== NOT EXECUTED 10aefe: e8 fd 3b 00 00 call 10eb00 <_Thread_Start> <== NOT EXECUTED 10af03: 88 c3 mov %al,%bl <== NOT EXECUTED start_routine, arg, 0 /* unused */ ); if ( schedpolicy == SCHED_SPORADIC ) { 10af05: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10af08: 83 7d cc 03 cmpl $0x3,-0x34(%ebp) <== NOT EXECUTED 10af0c: 0f 84 8a 00 00 00 je 10af9c <== NOT EXECUTED * * NOTE: This can only happen if someone slips in and touches the * thread while we are creating it. */ if ( !status ) { 10af12: 84 db test %bl,%bl <== NOT EXECUTED 10af14: 75 63 jne 10af79 <== NOT EXECUTED 10af16: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10af19: ff 75 a8 pushl -0x58(%ebp) <== NOT EXECUTED 10af1c: 68 80 36 12 00 push $0x123680 <== NOT EXECUTED 10af21: e8 3a 27 00 00 call 10d660 <_Objects_Free> <== NOT EXECUTED _POSIX_Threads_Free( the_thread ); _RTEMS_Unlock_allocator(); 10af26: 58 pop %eax <== NOT EXECUTED 10af27: ff 35 74 34 12 00 pushl 0x123474 <== NOT EXECUTED 10af2d: e8 4a 1a 00 00 call 10c97c <_API_Mutex_Unlock> <== NOT EXECUTED 10af32: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED 10af37: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af3a: e9 be fd ff ff jmp 10acfd <== NOT EXECUTED 10af3f: 90 nop <== NOT EXECUTED */ budget_callout = NULL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; switch ( schedpolicy ) { 10af40: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10af43: 85 c0 test %eax,%eax <== NOT EXECUTED 10af45: 0f 85 ad fd ff ff jne 10acf8 <== NOT EXECUTED 10af4b: c7 45 c4 01 00 00 00 movl $0x1,-0x3c(%ebp) <== NOT EXECUTED 10af52: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) <== NOT EXECUTED 10af59: e9 46 fe ff ff jmp 10ada4 <== NOT EXECUTED */ the_thread = _POSIX_Threads_Allocate(); if ( !the_thread ) { _RTEMS_Unlock_allocator(); 10af5e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af61: ff 35 74 34 12 00 pushl 0x123474 <== NOT EXECUTED 10af67: e8 10 1a 00 00 call 10c97c <_API_Mutex_Unlock> <== NOT EXECUTED 10af6c: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 10af71: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af74: e9 84 fd ff ff jmp 10acfd <== NOT EXECUTED /* * Return the id and indicate we successfully created the thread */ *thread = the_thread->Object.id; 10af79: 8b 75 a8 mov -0x58(%ebp),%esi <== NOT EXECUTED 10af7c: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10af7f: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10af82: 89 07 mov %eax,(%edi) <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10af84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af87: ff 35 74 34 12 00 pushl 0x123474 <== NOT EXECUTED 10af8d: e8 ea 19 00 00 call 10c97c <_API_Mutex_Unlock> <== NOT EXECUTED 10af92: 31 c0 xor %eax,%eax <== NOT EXECUTED 10af94: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af97: e9 61 fd ff ff jmp 10acfd <== NOT EXECUTED arg, 0 /* unused */ ); if ( schedpolicy == SCHED_SPORADIC ) { _Watchdog_Insert_ticks( 10af9c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af9f: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 10afa2: 05 88 00 00 00 add $0x88,%eax <== NOT EXECUTED 10afa7: 50 push %eax <== NOT EXECUTED 10afa8: e8 6b 3d 00 00 call 10ed18 <_Timespec_To_ticks> <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10afad: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 10afb0: 89 82 a8 00 00 00 mov %eax,0xa8(%edx) <== NOT EXECUTED void *starting_address, size_t *size 10afb6: 59 pop %ecx <== NOT EXECUTED 10afb7: 5e pop %esi <== NOT EXECUTED 10afb8: 89 d0 mov %edx,%eax <== NOT EXECUTED 10afba: 05 9c 00 00 00 add $0x9c,%eax <== NOT EXECUTED 10afbf: 50 push %eax <== NOT EXECUTED 10afc0: 68 9c 34 12 00 push $0x12349c <== NOT EXECUTED 10afc5: e8 d6 40 00 00 call 10f0a0 <_Watchdog_Insert> <== NOT EXECUTED 10afca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10afcd: e9 40 ff ff ff jmp 10af12 <== NOT EXECUTED 0010a3dc : #include int pthread_detach( pthread_t thread ) { 10a3dc: 55 push %ebp <== NOT EXECUTED 10a3dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a3df: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10a3e2: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10a3e5: 50 push %eax <== NOT EXECUTED 10a3e6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a3e9: 68 20 24 12 00 push $0x122420 <== NOT EXECUTED 10a3ee: e8 dd 24 00 00 call 10c8d0 <_Objects_Get> <== NOT EXECUTED register Thread_Control *the_thread; POSIX_API_Control *api; Objects_Locations location; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 10a3f3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a3f6: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10a3f9: 85 d2 test %edx,%edx <== NOT EXECUTED 10a3fb: 75 17 jne 10a414 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; api->detachstate = PTHREAD_CREATE_DETACHED; 10a3fd: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED 10a403: c7 40 38 00 00 00 00 movl $0x0,0x38(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a40a: e8 05 2d 00 00 call 10d114 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a40f: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10a411: c9 leave <== NOT EXECUTED 10a412: c3 ret <== NOT EXECUTED 10a413: 90 nop <== NOT EXECUTED register Thread_Control *the_thread; POSIX_API_Control *api; Objects_Locations location; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 10a414: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10a419: c9 leave <== NOT EXECUTED 10a41a: c3 ret <== NOT EXECUTED 0010afd4 : int pthread_equal( pthread_t t1, pthread_t t2 ) { 10afd4: 55 push %ebp <== NOT EXECUTED 10afd5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10afd7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10afda: 39 45 08 cmp %eax,0x8(%ebp) <== NOT EXECUTED 10afdd: 0f 94 c0 sete %al <== NOT EXECUTED 10afe0: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED break; } return status; #endif } 10afe3: c9 leave <== NOT EXECUTED 10afe4: c3 ret <== NOT EXECUTED 00110770 : } void pthread_exit( void *value_ptr ) { 110770: 55 push %ebp <== NOT EXECUTED 110771: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110773: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED _POSIX_Thread_Exit( _Thread_Executing, value_ptr ); 110776: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 110779: ff 35 7c f8 11 00 pushl 0x11f87c <== NOT EXECUTED 11077f: e8 88 ff ff ff call 11070c <_POSIX_Thread_Exit> <== NOT EXECUTED 110784: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 110787: c9 leave <== NOT EXECUTED 110788: c3 ret <== NOT EXECUTED 0010a3c0 : int pthread_getcpuclockid( pthread_t pid, clockid_t *clock_id ) { 10a3c0: 55 push %ebp <== NOT EXECUTED 10a3c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a3c3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a3c6: e8 b5 76 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a3cb: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a3d1: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a3d6: c9 leave <== NOT EXECUTED 10a3d7: c3 ret <== NOT EXECUTED 0010c518 : int pthread_getschedparam( pthread_t thread, int *policy, struct sched_param *param ) { 10c518: 55 push %ebp <== NOT EXECUTED 10c519: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c51b: 57 push %edi <== NOT EXECUTED 10c51c: 56 push %esi <== NOT EXECUTED 10c51d: 53 push %ebx <== NOT EXECUTED 10c51e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10c521: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Locations location; POSIX_API_Control *api; register Thread_Control *the_thread; if ( !policy || !param ) 10c524: 85 f6 test %esi,%esi <== NOT EXECUTED 10c526: 74 6c je 10c594 <== NOT EXECUTED 10c528: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10c52b: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10c52d: 74 65 je 10c594 <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10c52f: 52 push %edx <== NOT EXECUTED 10c530: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c533: 50 push %eax <== NOT EXECUTED 10c534: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c537: 68 60 54 12 00 push $0x125460 <== NOT EXECUTED 10c53c: e8 cf 25 00 00 call 10eb10 <_Objects_Get> <== NOT EXECUTED 10c541: 89 c3 mov %eax,%ebx <== NOT EXECUTED return EINVAL; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 10c543: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c546: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10c549: 85 c0 test %eax,%eax <== NOT EXECUTED 10c54b: 75 37 jne 10c584 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10c54d: 8b 93 f8 00 00 00 mov 0xf8(%ebx),%edx <== NOT EXECUTED if ( policy ) *policy = api->schedpolicy; 10c553: 8b 42 7c mov 0x7c(%edx),%eax <== NOT EXECUTED 10c556: 89 06 mov %eax,(%esi) <== NOT EXECUTED if ( param ) { *param = api->schedparam; 10c558: 8d b2 80 00 00 00 lea 0x80(%edx),%esi <== NOT EXECUTED 10c55e: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10c563: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10c566: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED param->sched_priority = 10c568: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10c56d: 2b 43 14 sub 0x14(%ebx),%eax <== NOT EXECUTED 10c570: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10c573: 89 02 mov %eax,(%edx) <== NOT EXECUTED _POSIX_Priority_From_core( the_thread->current_priority ); } _Thread_Enable_dispatch(); 10c575: e8 da 2d 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c57a: 31 c0 xor %eax,%eax <== NOT EXECUTED break; } return ESRCH; } 10c57c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c57f: 5b pop %ebx <== NOT EXECUTED 10c580: 5e pop %esi <== NOT EXECUTED 10c581: 5f pop %edi <== NOT EXECUTED 10c582: c9 leave <== NOT EXECUTED 10c583: c3 ret <== NOT EXECUTED if ( !policy || !param ) return EINVAL; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 10c584: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED break; } return ESRCH; } 10c589: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c58c: 5b pop %ebx <== NOT EXECUTED 10c58d: 5e pop %esi <== NOT EXECUTED 10c58e: 5f pop %edi <== NOT EXECUTED 10c58f: c9 leave <== NOT EXECUTED 10c590: c3 ret <== NOT EXECUTED 10c591: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED *param = api->schedparam; param->sched_priority = _POSIX_Priority_From_core( the_thread->current_priority ); } _Thread_Enable_dispatch(); return 0; 10c594: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED break; } return ESRCH; } 10c599: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c59c: 5b pop %ebx <== NOT EXECUTED 10c59d: 5e pop %esi <== NOT EXECUTED 10c59e: 5f pop %edi <== NOT EXECUTED 10c59f: c9 leave <== NOT EXECUTED 10c5a0: c3 ret <== NOT EXECUTED 0010a26c : */ void *pthread_getspecific( pthread_key_t key ) { 10a26c: 55 push %ebp <== NOT EXECUTED 10a26d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a26f: 53 push %ebx <== NOT EXECUTED 10a270: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10a273: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a276: 50 push %eax <== NOT EXECUTED 10a277: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a27a: 68 40 27 12 00 push $0x122740 <== NOT EXECUTED 10a27f: e8 ec 27 00 00 call 10ca70 <_Objects_Get> <== NOT EXECUTED 10a284: 89 c1 mov %eax,%ecx <== NOT EXECUTED uint32_t index; Objects_Locations location; void *key_data; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 10a286: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a289: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10a28c: 85 c0 test %eax,%eax <== NOT EXECUTED 10a28e: 75 2c jne 10a2bc <== NOT EXECUTED case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 10a290: a1 5c 23 12 00 mov 0x12235c,%eax <== NOT EXECUTED 10a295: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED index = _Objects_Get_index( _Thread_Executing->Object.id ); key_data = (void *) the_key->Values[ api ][ index ]; 10a298: 89 d0 mov %edx,%eax <== NOT EXECUTED 10a29a: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10a29d: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10a2a0: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10a2a6: 8b 44 81 18 mov 0x18(%ecx,%eax,4),%eax <== NOT EXECUTED 10a2aa: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED _Thread_Enable_dispatch(); 10a2ad: e8 02 30 00 00 call 10d2b4 <_Thread_Enable_dispatch> <== NOT EXECUTED case OBJECTS_ERROR: break; } return NULL; } 10a2b2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a2b4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a2b7: c9 leave <== NOT EXECUTED 10a2b8: c3 ret <== NOT EXECUTED 10a2b9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED uint32_t index; Objects_Locations location; void *key_data; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 10a2bc: 31 db xor %ebx,%ebx <== NOT EXECUTED case OBJECTS_ERROR: break; } return NULL; } 10a2be: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a2c0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a2c3: c9 leave <== NOT EXECUTED 10a2c4: c3 ret <== NOT EXECUTED 0010e52c : int pthread_join( pthread_t thread, void **value_ptr ) { 10e52c: 55 push %ebp <== NOT EXECUTED 10e52d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e52f: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10e532: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10e535: 50 push %eax <== NOT EXECUTED 10e536: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10e539: 68 60 93 12 00 push $0x129360 <== NOT EXECUTED 10e53e: e8 a5 25 00 00 call 110ae8 <_Objects_Get> <== NOT EXECUTED POSIX_API_Control *api; Objects_Locations location; void *return_pointer; the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 10e543: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e546: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10e549: 85 d2 test %edx,%edx <== NOT EXECUTED 10e54b: 74 07 je 10e554 <== NOT EXECUTED 10e54d: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10e552: c9 leave <== NOT EXECUTED 10e553: c3 ret <== NOT EXECUTED the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10e554: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED if ( api->detachstate == PTHREAD_CREATE_DETACHED ) { 10e55a: 8b 4a 38 mov 0x38(%edx),%ecx <== NOT EXECUTED 10e55d: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10e55f: 74 43 je 10e5a4 <== NOT EXECUTED 10e561: 8b 0d 5c 91 12 00 mov 0x12915c,%ecx <== NOT EXECUTED _Thread_Enable_dispatch(); return EINVAL; } if ( _Thread_Is_executing( the_thread ) ) { 10e567: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10e569: 74 45 je 10e5b0 <== NOT EXECUTED /* * Put ourself on the threads join list */ _Thread_Executing->Wait.return_argument = &return_pointer; 10e56b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10e56e: 89 41 28 mov %eax,0x28(%ecx) <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10e571: c7 42 6c 01 00 00 00 movl $0x1,0x6c(%edx) <== NOT EXECUTED _Thread_queue_Enter_critical_section( &api->Join_List ); _Thread_queue_Enqueue( &api->Join_List, WATCHDOG_NO_TIMEOUT ); 10e578: 51 push %ecx <== NOT EXECUTED 10e579: 68 3c 1b 11 00 push $0x111b3c <== NOT EXECUTED 10e57e: 6a 00 push $0x0 <== NOT EXECUTED 10e580: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10e583: 50 push %eax <== NOT EXECUTED 10e584: e8 63 32 00 00 call 1117ec <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 10e589: e8 9e 2d 00 00 call 11132c <_Thread_Enable_dispatch> <== NOT EXECUTED if ( value_ptr ) 10e58e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e591: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e594: 85 c0 test %eax,%eax <== NOT EXECUTED 10e596: 74 08 je 10e5a0 <== NOT EXECUTED *value_ptr = return_pointer; 10e598: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10e59b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10e59e: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10e5a0: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10e5a2: c9 leave <== NOT EXECUTED 10e5a3: c3 ret <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( api->detachstate == PTHREAD_CREATE_DETACHED ) { _Thread_Enable_dispatch(); 10e5a4: e8 83 2d 00 00 call 11132c <_Thread_Enable_dispatch> <== NOT EXECUTED 10e5a9: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10e5ae: c9 leave <== NOT EXECUTED 10e5af: c3 ret <== NOT EXECUTED _Thread_Enable_dispatch(); return EINVAL; } if ( _Thread_Is_executing( the_thread ) ) { _Thread_Enable_dispatch(); 10e5b0: e8 77 2d 00 00 call 11132c <_Thread_Enable_dispatch> <== NOT EXECUTED 10e5b5: b8 2d 00 00 00 mov $0x2d,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10e5ba: c9 leave <== NOT EXECUTED 10e5bb: c3 ret <== NOT EXECUTED 0010a0ac : int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) { 10a0ac: 55 push %ebp <== NOT EXECUTED 10a0ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a0af: 57 push %edi <== NOT EXECUTED 10a0b0: 56 push %esi <== NOT EXECUTED 10a0b1: 53 push %ebx <== NOT EXECUTED 10a0b2: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10a0b5: a1 98 22 12 00 mov 0x122298,%eax <== NOT EXECUTED 10a0ba: 40 inc %eax <== NOT EXECUTED 10a0bb: a3 98 22 12 00 mov %eax,0x122298 <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 10a0c0: 68 40 27 12 00 push $0x122740 <== NOT EXECUTED 10a0c5: e8 b2 24 00 00 call 10c57c <_Objects_Allocate> <== NOT EXECUTED 10a0ca: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { 10a0cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0d0: 85 c0 test %eax,%eax <== NOT EXECUTED 10a0d2: 0f 84 8c 00 00 00 je 10a164 <== NOT EXECUTED _Thread_Enable_dispatch(); return EAGAIN; } the_key->destructor = destructor; 10a0d8: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10a0db: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10a0de: 89 50 14 mov %edx,0x14(%eax) <== NOT EXECUTED 10a0e1: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { if ( _Objects_Information_table[ the_api ] ) { 10a0e6: 8b 04 9d 6c 22 12 00 mov 0x12226c(,%ebx,4),%eax <== NOT EXECUTED 10a0ed: 85 c0 test %eax,%eax <== NOT EXECUTED 10a0ef: 74 63 je 10a154 <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_IMPLEMENTATION_KEY_CREATE_INCONSISTENCY ); #endif bytes_to_allocate = sizeof( void * ) * 10a0f1: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10a0f4: 0f b7 40 10 movzwl 0x10(%eax),%eax <== NOT EXECUTED 10a0f8: 8d 34 85 04 00 00 00 lea 0x4(,%eax,4),%esi <== NOT EXECUTED (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); 10a0ff: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a102: 56 push %esi <== NOT EXECUTED 10a103: e8 fc 43 00 00 call 10e504 <_Workspace_Allocate> <== NOT EXECUTED 10a108: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( !table ) { 10a10a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a10d: 85 c0 test %eax,%eax <== NOT EXECUTED 10a10f: 74 67 je 10a178 <== NOT EXECUTED _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); return ENOMEM; } the_key->Values[ the_api ] = table; 10a111: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10a114: 89 44 9a 18 mov %eax,0x18(%edx,%ebx,4) <== NOT EXECUTED memset( table, '\0', bytes_to_allocate ); 10a118: 89 f1 mov %esi,%ecx <== NOT EXECUTED 10a11a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a11c: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED * for. [NOTE: Currently RTEMS Classic API tasks are always enabled.] */ for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) { 10a11e: 43 inc %ebx <== NOT EXECUTED * 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; 10a11f: 83 fb 05 cmp $0x5,%ebx <== NOT EXECUTED 10a122: 75 c2 jne 10a0e6 <== NOT EXECUTED } } the_key->is_active = TRUE; 10a124: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 10a127: c6 43 10 01 movb $0x1,0x10(%ebx) <== NOT EXECUTED 10a12b: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10a12e: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10a131: a1 5c 27 12 00 mov 0x12275c,%eax <== NOT EXECUTED 10a136: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10a139: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED _Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; 10a140: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a143: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a145: e8 6a 31 00 00 call 10d2b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a14a: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10a14c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a14f: 5b pop %ebx <== NOT EXECUTED 10a150: 5e pop %esi <== NOT EXECUTED 10a151: 5f pop %edi <== NOT EXECUTED 10a152: c9 leave <== NOT EXECUTED 10a153: c3 ret <== NOT EXECUTED } the_key->Values[ the_api ] = table; memset( table, '\0', bytes_to_allocate ); } else { the_key->Values[ the_api ] = NULL; 10a154: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10a157: c7 44 9a 18 00 00 00 movl $0x0,0x18(%edx,%ebx,4) <== NOT EXECUTED 10a15e: 00 <== NOT EXECUTED 10a15f: eb bd jmp 10a11e <== NOT EXECUTED 10a161: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { _Thread_Enable_dispatch(); 10a164: e8 4b 31 00 00 call 10d2b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a169: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED *key = the_key->Object.id; _Thread_Enable_dispatch(); return 0; } 10a16e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a171: 5b pop %ebx <== NOT EXECUTED 10a172: 5e pop %esi <== NOT EXECUTED 10a173: 5f pop %edi <== NOT EXECUTED 10a174: c9 leave <== NOT EXECUTED 10a175: c3 ret <== NOT EXECUTED 10a176: 66 90 xchg %ax,%ax <== NOT EXECUTED 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; 10a178: 89 de mov %ebx,%esi <== NOT EXECUTED 10a17a: 4e dec %esi <== NOT EXECUTED 10a17b: 74 1a je 10a197 <== NOT EXECUTED 10a17d: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10a180: 8d 5c 98 14 lea 0x14(%eax,%ebx,4),%ebx <== NOT EXECUTED the_api-- ) _Workspace_Free( the_key->Values[ the_api ] ); 10a184: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a187: ff 33 pushl (%ebx) <== NOT EXECUTED 10a189: e8 5e 43 00 00 call 10e4ec <_Workspace_Free> <== NOT EXECUTED (_Objects_Information_table[ the_api ][ 1 ]->maximum + 1); table = _Workspace_Allocate( bytes_to_allocate ); if ( !table ) { for ( --the_api; the_api >= 1; the_api-- ) 10a18e: 83 eb 04 sub $0x4,%ebx <== NOT EXECUTED 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; 10a191: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a194: 4e dec %esi <== NOT EXECUTED 10a195: 75 ed jne 10a184 <== NOT EXECUTED * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 10a197: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a19a: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10a19d: 68 40 27 12 00 push $0x122740 <== NOT EXECUTED 10a1a2: e8 95 27 00 00 call 10c93c <_Objects_Free> <== NOT EXECUTED the_api-- ) _Workspace_Free( the_key->Values[ the_api ] ); _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 10a1a7: e8 08 31 00 00 call 10d2b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a1ac: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED 10a1b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1b4: eb 96 jmp 10a14c <== NOT EXECUTED 0010a1b8 : */ int pthread_key_delete( pthread_key_t key ) { 10a1b8: 55 push %ebp <== NOT EXECUTED 10a1b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a1bb: 53 push %ebx <== NOT EXECUTED 10a1bc: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10a1bf: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a1c2: 50 push %eax <== NOT EXECUTED 10a1c3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a1c6: 68 40 27 12 00 push $0x122740 <== NOT EXECUTED 10a1cb: e8 a0 28 00 00 call 10ca70 <_Objects_Get> <== NOT EXECUTED 10a1d0: 89 c3 mov %eax,%ebx <== NOT EXECUTED register POSIX_Keys_Control *the_key; Objects_Locations location; uint32_t the_api; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 10a1d2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1d5: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10a1d8: 85 c0 test %eax,%eax <== NOT EXECUTED 10a1da: 0f 85 80 00 00 00 jne 10a260 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Keys_Information, &the_key->Object ); 10a1e0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a1e3: 53 push %ebx <== NOT EXECUTED 10a1e4: 68 40 27 12 00 push $0x122740 <== NOT EXECUTED 10a1e9: e8 0e 24 00 00 call 10c5fc <_Objects_Close> <== NOT EXECUTED the_key->is_active = FALSE; 10a1ee: c6 43 10 00 movb $0x0,0x10(%ebx) <== NOT EXECUTED for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 10a1f2: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10a1f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1f8: 85 c0 test %eax,%eax <== NOT EXECUTED 10a1fa: 74 0c je 10a208 <== NOT EXECUTED _Workspace_Free( the_key->Values[ the_api ] ); 10a1fc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a1ff: 50 push %eax <== NOT EXECUTED 10a200: e8 e7 42 00 00 call 10e4ec <_Workspace_Free> <== NOT EXECUTED 10a205: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 10a208: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 10a20b: 85 c0 test %eax,%eax <== NOT EXECUTED 10a20d: 74 0c je 10a21b <== NOT EXECUTED _Workspace_Free( the_key->Values[ the_api ] ); 10a20f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a212: 50 push %eax <== NOT EXECUTED 10a213: e8 d4 42 00 00 call 10e4ec <_Workspace_Free> <== NOT EXECUTED 10a218: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 10a21b: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 10a21e: 85 c0 test %eax,%eax <== NOT EXECUTED 10a220: 74 0c je 10a22e <== NOT EXECUTED _Workspace_Free( the_key->Values[ the_api ] ); 10a222: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a225: 50 push %eax <== NOT EXECUTED 10a226: e8 c1 42 00 00 call 10e4ec <_Workspace_Free> <== NOT EXECUTED 10a22b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_key->is_active = FALSE; for ( the_api = 1; the_api <= OBJECTS_APIS_LAST; the_api++ ) if ( the_key->Values[ the_api ] ) 10a22e: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10a231: 85 c0 test %eax,%eax <== NOT EXECUTED 10a233: 74 0c je 10a241 <== NOT EXECUTED _Workspace_Free( the_key->Values[ the_api ] ); 10a235: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a238: 50 push %eax <== NOT EXECUTED 10a239: e8 ae 42 00 00 call 10e4ec <_Workspace_Free> <== NOT EXECUTED 10a23e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 10a241: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a244: 53 push %ebx <== NOT EXECUTED 10a245: 68 40 27 12 00 push $0x122740 <== NOT EXECUTED 10a24a: e8 ed 26 00 00 call 10c93c <_Objects_Free> <== NOT EXECUTED * NOTE: The destructor is not called and it is the responsibility * of the application to free the memory. */ _POSIX_Keys_Free( the_key ); _Thread_Enable_dispatch(); 10a24f: e8 60 30 00 00 call 10d2b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a254: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a256: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a259: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a25c: c9 leave <== NOT EXECUTED 10a25d: c3 ret <== NOT EXECUTED 10a25e: 66 90 xchg %ax,%ax <== NOT EXECUTED register POSIX_Keys_Control *the_key; Objects_Locations location; uint32_t the_api; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 10a260: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a265: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a268: c9 leave <== NOT EXECUTED 10a269: c3 ret <== NOT EXECUTED 00121f88 : int pthread_kill( pthread_t thread, int sig ) { 121f88: 55 push %ebp <== NOT EXECUTED 121f89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 121f8b: 57 push %edi <== NOT EXECUTED 121f8c: 56 push %esi <== NOT EXECUTED 121f8d: 53 push %ebx <== NOT EXECUTED 121f8e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 121f91: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED POSIX_API_Control *api; Thread_Control *the_thread; Objects_Locations location; if ( !sig ) 121f94: 85 f6 test %esi,%esi <== NOT EXECUTED 121f96: 0f 84 8c 00 00 00 je 122028 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 121f9c: 8d 7e ff lea -0x1(%esi),%edi <== NOT EXECUTED 121f9f: 83 ff 1f cmp $0x1f,%edi <== NOT EXECUTED 121fa2: 0f 87 80 00 00 00 ja 122028 <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 121fa8: 51 push %ecx <== NOT EXECUTED 121fa9: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 121fac: 50 push %eax <== NOT EXECUTED 121fad: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 121fb0: 68 c0 df 12 00 push $0x12dfc0 <== NOT EXECUTED 121fb5: e8 5a e9 fe ff call 110914 <_Objects_Get> <== NOT EXECUTED 121fba: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 121fbc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121fbf: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 121fc2: 85 d2 test %edx,%edx <== NOT EXECUTED 121fc4: 75 76 jne 12203c <== NOT EXECUTED case OBJECTS_LOCAL: /* * If sig == 0 then just validate arguments */ api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 121fc6: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED if ( sig ) { if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) { 121fcc: 8d 04 76 lea (%esi,%esi,2),%eax <== NOT EXECUTED 121fcf: 83 3c 85 88 e3 12 00 cmpl $0x1,0x12e388(,%eax,4) <== NOT EXECUTED 121fd6: 01 <== NOT EXECUTED 121fd7: 74 31 je 12200a <== NOT EXECUTED return 0; } /* XXX critical section */ api->signals_pending |= signo_to_mask( sig ); 121fd9: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 121fde: 89 f9 mov %edi,%ecx <== NOT EXECUTED 121fe0: d3 e0 shl %cl,%eax <== NOT EXECUTED 121fe2: 09 82 c8 00 00 00 or %eax,0xc8(%edx) <== NOT EXECUTED (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); 121fe8: 50 push %eax <== NOT EXECUTED 121fe9: 6a 00 push $0x0 <== NOT EXECUTED 121feb: 56 push %esi <== NOT EXECUTED 121fec: 53 push %ebx <== NOT EXECUTED 121fed: e8 7a fe ff ff call 121e6c <_POSIX_signals_Unblock_thread> <== NOT EXECUTED the_thread->do_post_task_switch_extension = true; 121ff2: c6 43 75 01 movb $0x1,0x75(%ebx) <== NOT EXECUTED if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 121ff6: a1 58 dd 12 00 mov 0x12dd58,%eax <== NOT EXECUTED 121ffb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 121ffe: 85 c0 test %eax,%eax <== NOT EXECUTED 122000: 74 08 je 12200a <== NOT EXECUTED 122002: 3b 1d 7c dd 12 00 cmp 0x12dd7c,%ebx <== NOT EXECUTED 122008: 74 12 je 12201c <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; } _Thread_Enable_dispatch(); 12200a: e8 49 f1 fe ff call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 12200f: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); } 122011: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 122014: 5b pop %ebx <== NOT EXECUTED 122015: 5e pop %esi <== NOT EXECUTED 122016: 5f pop %edi <== NOT EXECUTED 122017: c9 leave <== NOT EXECUTED 122018: c3 ret <== NOT EXECUTED 122019: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED (void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL ); the_thread->do_post_task_switch_extension = true; if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) _ISR_Signals_to_thread_executing = TRUE; 12201c: c6 05 28 de 12 00 01 movb $0x1,0x12de28 <== NOT EXECUTED 122023: eb e5 jmp 12200a <== NOT EXECUTED 122025: 8d 76 00 lea 0x0(%esi),%esi <== 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 ); 122028: e8 4f 76 ff ff call 11967c <__errno> <== NOT EXECUTED 12202d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 122033: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 122038: eb d7 jmp 122011 <== NOT EXECUTED 12203a: 66 90 xchg %ax,%ax <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( ESRCH ); 12203c: e8 3b 76 ff ff call 11967c <__errno> <== NOT EXECUTED 122041: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED 122047: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12204c: eb c3 jmp 122011 <== NOT EXECUTED 0010bc78 : */ int pthread_mutex_destroy( pthread_mutex_t *mutex ) { 10bc78: 55 push %ebp <== NOT EXECUTED 10bc79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc7b: 53 push %ebx <== NOT EXECUTED 10bc7c: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; the_mutex = _POSIX_Mutex_Get( mutex, &location ); 10bc7f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10bc82: 50 push %eax <== NOT EXECUTED 10bc83: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bc86: e8 c5 00 00 00 call 10bd50 <_POSIX_Mutex_Get> <== NOT EXECUTED 10bc8b: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch ( location ) { 10bc8d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bc90: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10bc93: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc95: 74 0d je 10bca4 <== NOT EXECUTED 10bc97: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10bc9c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bc9f: c9 leave <== NOT EXECUTED 10bca0: c3 ret <== NOT EXECUTED 10bca1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * XXX: There is an error for the mutex being locked * or being in use by a condition variable. */ if ( _CORE_mutex_Is_locked( &the_mutex->Mutex ) ) { 10bca4: 8b 4b 64 mov 0x64(%ebx),%ecx <== NOT EXECUTED 10bca7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bca9: 75 11 jne 10bcbc <== NOT EXECUTED _Thread_Enable_dispatch(); 10bcab: e8 a4 36 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED 10bcb0: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10bcb5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bcb8: c9 leave <== NOT EXECUTED 10bcb9: c3 ret <== NOT EXECUTED 10bcba: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( _CORE_mutex_Is_locked( &the_mutex->Mutex ) ) { _Thread_Enable_dispatch(); return EBUSY; } _Objects_Close( &_POSIX_Mutex_Information, &the_mutex->Object ); 10bcbc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bcbf: 53 push %ebx <== NOT EXECUTED 10bcc0: 68 a0 55 12 00 push $0x1255a0 <== NOT EXECUTED 10bcc5: e8 d2 29 00 00 call 10e69c <_Objects_Close> <== NOT EXECUTED _CORE_mutex_Flush( &the_mutex->Mutex, NULL, EINVAL ); 10bcca: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10bccd: 6a 16 push $0x16 <== NOT EXECUTED 10bccf: 6a 00 push $0x0 <== NOT EXECUTED 10bcd1: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 10bcd4: 50 push %eax <== NOT EXECUTED 10bcd5: e8 1a 22 00 00 call 10def4 <_CORE_mutex_Flush> <== NOT EXECUTED * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for 10bcda: 58 pop %eax <== NOT EXECUTED 10bcdb: 5a pop %edx <== NOT EXECUTED 10bcdc: 53 push %ebx <== NOT EXECUTED 10bcdd: 68 a0 55 12 00 push $0x1255a0 <== NOT EXECUTED 10bce2: e8 f5 2c 00 00 call 10e9dc <_Objects_Free> <== NOT EXECUTED _POSIX_Mutex_Free( the_mutex ); _Thread_Enable_dispatch(); 10bce7: e8 68 36 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED 10bcec: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bcee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10bcf1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bcf4: c9 leave <== NOT EXECUTED 10bcf5: c3 ret <== NOT EXECUTED 0010bda4 : int pthread_mutex_getprioceiling( pthread_mutex_t *mutex, int *prioceiling ) { 10bda4: 55 push %ebp <== NOT EXECUTED 10bda5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bda7: 53 push %ebx <== NOT EXECUTED 10bda8: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10bdab: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; if ( !prioceiling ) 10bdae: 85 db test %ebx,%ebx <== NOT EXECUTED 10bdb0: 74 1b je 10bdcd <== NOT EXECUTED return EINVAL; the_mutex = _POSIX_Mutex_Get( mutex, &location ); 10bdb2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bdb5: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10bdb8: 50 push %eax <== NOT EXECUTED 10bdb9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bdbc: e8 8f ff ff ff call 10bd50 <_POSIX_Mutex_Get> <== NOT EXECUTED 10bdc1: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 10bdc3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bdc6: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10bdc9: 85 c0 test %eax,%eax <== NOT EXECUTED 10bdcb: 74 0b je 10bdd8 <== NOT EXECUTED case OBJECTS_LOCAL: *prioceiling = _POSIX_Priority_From_core( the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); return 0; 10bdcd: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10bdd2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bdd5: c9 leave <== NOT EXECUTED 10bdd6: c3 ret <== NOT EXECUTED 10bdd7: 90 nop <== NOT EXECUTED the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { case OBJECTS_LOCAL: *prioceiling = _POSIX_Priority_From_core( 10bdd8: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10bddd: 2b 42 60 sub 0x60(%edx),%eax <== NOT EXECUTED 10bde0: 89 03 mov %eax,(%ebx) <== NOT EXECUTED the_mutex->Mutex.Attributes.priority_ceiling ); _Thread_Enable_dispatch(); 10bde2: e8 6d 35 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED 10bde7: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10bde9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bdec: c9 leave <== NOT EXECUTED 10bded: c3 ret <== NOT EXECUTED 0010bdf0 : int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr ) { 10bdf0: 55 push %ebp <== NOT EXECUTED 10bdf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bdf3: 57 push %edi <== NOT EXECUTED 10bdf4: 56 push %esi <== NOT EXECUTED 10bdf5: 53 push %ebx <== NOT EXECUTED 10bdf6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bdf9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED #if 0 register POSIX_Mutex_Control *mutex_in_use; Objects_Locations location; #endif if ( attr ) the_attr = attr; 10bdfc: 85 c0 test %eax,%eax <== NOT EXECUTED 10bdfe: 0f 84 e0 00 00 00 je 10bee4 <== NOT EXECUTED 10be04: 89 c3 mov %eax,%ebx <== NOT EXECUTED else the_attr = &_POSIX_Mutex_Default_attributes; /* Check for NULL mutex */ if ( !mutex ) 10be06: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10be09: 85 f6 test %esi,%esi <== NOT EXECUTED 10be0b: 0f 84 c3 00 00 00 je 10bed4 <== NOT EXECUTED break; } } #endif if ( !the_attr->is_initialized ) 10be11: 8b 0b mov (%ebx),%ecx <== NOT EXECUTED 10be13: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10be15: 0f 84 b9 00 00 00 je 10bed4 <== NOT EXECUTED /* * XXX: Be careful about attributes when global!!! */ assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE ); 10be1b: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 10be1e: 85 d2 test %edx,%edx <== NOT EXECUTED 10be20: 0f 85 ee 00 00 00 jne 10bf14 <== NOT EXECUTED /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 10be26: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10be29: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10be2c: 0f 84 be 00 00 00 je 10bef0 <== NOT EXECUTED 10be32: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10be35: 0f 84 c1 00 00 00 je 10befc <== NOT EXECUTED 10be3b: 85 c0 test %eax,%eax <== NOT EXECUTED 10be3d: 0f 85 91 00 00 00 jne 10bed4 <== NOT EXECUTED 10be43: 31 ff xor %edi,%edi <== NOT EXECUTED break; default: return EINVAL; } if ( !_POSIX_Priority_Is_valid( the_attr->prio_ceiling ) ) 10be45: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10be48: 48 dec %eax <== NOT EXECUTED 10be49: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10be4e: 0f 87 80 00 00 00 ja 10bed4 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10be54: a1 98 51 12 00 mov 0x125198,%eax <== NOT EXECUTED 10be59: 40 inc %eax <== NOT EXECUTED 10be5a: a3 98 51 12 00 mov %eax,0x125198 <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 10be5f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10be62: 68 a0 55 12 00 push $0x1255a0 <== NOT EXECUTED 10be67: e8 b0 27 00 00 call 10e61c <_Objects_Allocate> <== NOT EXECUTED 10be6c: 89 c6 mov %eax,%esi <== NOT EXECUTED _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { 10be6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10be71: 85 c0 test %eax,%eax <== NOT EXECUTED 10be73: 0f 84 8f 00 00 00 je 10bf08 <== NOT EXECUTED _Thread_Enable_dispatch(); return EAGAIN; } the_mutex->process_shared = the_attr->process_shared; 10be79: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10be7c: 89 46 10 mov %eax,0x10(%esi) <== NOT EXECUTED the_mutex_attr = &the_mutex->Mutex.Attributes; if ( the_attr->recursive ) the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 10be7f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10be81: 83 7b 10 00 cmpl $0x0,0x10(%ebx) <== NOT EXECUTED 10be85: 0f 94 c0 sete %al <== NOT EXECUTED 10be88: 89 46 54 mov %eax,0x54(%esi) <== NOT EXECUTED else the_mutex_attr->lock_nesting_behavior = CORE_MUTEX_NESTING_IS_ERROR; the_mutex_attr->only_owner_release = TRUE; 10be8b: c6 46 58 01 movb $0x1,0x58(%esi) <== NOT EXECUTED the_mutex_attr->priority_ceiling = 10be8f: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10be94: 2b 43 08 sub 0x8(%ebx),%eax <== NOT EXECUTED 10be97: 89 46 60 mov %eax,0x60(%esi) <== NOT EXECUTED _POSIX_Priority_To_core( the_attr->prio_ceiling ); the_mutex_attr->discipline = the_discipline; 10be9a: 89 7e 5c mov %edi,0x5c(%esi) <== NOT EXECUTED /* * Must be initialized to unlocked. */ _CORE_mutex_Initialize( 10be9d: 50 push %eax <== NOT EXECUTED 10be9e: 6a 01 push $0x1 <== NOT EXECUTED 10bea0: 8d 46 54 lea 0x54(%esi),%eax <== NOT EXECUTED 10bea3: 50 push %eax <== NOT EXECUTED 10bea4: 8d 46 14 lea 0x14(%esi),%eax <== NOT EXECUTED 10bea7: 50 push %eax <== NOT EXECUTED 10bea8: e8 53 20 00 00 call 10df00 <_CORE_mutex_Initialize> <== NOT EXECUTED 10bead: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED 10beb0: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10beb3: a1 bc 55 12 00 mov 0x1255bc,%eax <== NOT EXECUTED 10beb8: 89 34 90 mov %esi,(%eax,%edx,4) <== NOT EXECUTED 10bebb: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) <== NOT EXECUTED CORE_MUTEX_UNLOCKED ); _Objects_Open_u32( &_POSIX_Mutex_Information, &the_mutex->Object, 0 ); *mutex = the_mutex->Object.id; 10bec2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bec5: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10bec7: e8 88 34 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED 10becc: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bece: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bed1: eb 06 jmp 10bed9 <== NOT EXECUTED 10bed3: 90 nop <== NOT EXECUTED return 0; 10bed4: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10bed9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bedc: 5b pop %ebx <== NOT EXECUTED 10bedd: 5e pop %esi <== NOT EXECUTED 10bede: 5f pop %edi <== NOT EXECUTED 10bedf: c9 leave <== NOT EXECUTED 10bee0: c3 ret <== NOT EXECUTED 10bee1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED #if 0 register POSIX_Mutex_Control *mutex_in_use; Objects_Locations location; #endif if ( attr ) the_attr = attr; 10bee4: bb e8 e6 11 00 mov $0x11e6e8,%ebx <== NOT EXECUTED 10bee9: e9 18 ff ff ff jmp 10be06 <== NOT EXECUTED 10beee: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Determine the discipline of the mutex */ switch ( the_attr->protocol ) { 10bef0: bf 02 00 00 00 mov $0x2,%edi <== NOT EXECUTED 10bef5: e9 4b ff ff ff jmp 10be45 <== NOT EXECUTED 10befa: 66 90 xchg %ax,%ax <== NOT EXECUTED 10befc: bf 03 00 00 00 mov $0x3,%edi <== NOT EXECUTED 10bf01: e9 3f ff ff ff jmp 10be45 <== NOT EXECUTED 10bf06: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_Disable_dispatch(); the_mutex = _POSIX_Mutex_Allocate(); if ( !the_mutex ) { _Thread_Enable_dispatch(); 10bf08: e8 47 34 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED 10bf0d: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 10bf12: eb c5 jmp 10bed9 <== NOT EXECUTED /* * XXX: Be careful about attributes when global!!! */ assert( the_attr->process_shared == PTHREAD_PROCESS_PRIVATE ); 10bf14: 68 fc e6 11 00 push $0x11e6fc <== NOT EXECUTED 10bf19: 68 76 e7 11 00 push $0x11e776 <== NOT EXECUTED 10bf1e: 6a 68 push $0x68 <== NOT EXECUTED 10bf20: 68 30 e7 11 00 push $0x11e730 <== NOT EXECUTED 10bf25: e8 ae ce ff ff call 108dd8 <__assert_func> <== NOT EXECUTED 0010bf2c : */ int pthread_mutex_lock( pthread_mutex_t *mutex ) { 10bf2c: 55 push %ebp <== NOT EXECUTED 10bf2d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf2f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return _POSIX_Mutex_Lock_support( mutex, TRUE, THREAD_QUEUE_WAIT_FOREVER ); 10bf32: 6a 00 push $0x0 <== NOT EXECUTED 10bf34: 6a 01 push $0x1 <== NOT EXECUTED 10bf36: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bf39: e8 02 00 00 00 call 10bf40 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED } 10bf3e: c9 leave <== NOT EXECUTED 10bf3f: c3 ret <== NOT EXECUTED 0010bfa4 : int pthread_mutex_setprioceiling( pthread_mutex_t *mutex, int prioceiling, int *old_ceiling ) { 10bfa4: 55 push %ebp <== NOT EXECUTED 10bfa5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bfa7: 56 push %esi <== NOT EXECUTED 10bfa8: 53 push %ebx <== NOT EXECUTED 10bfa9: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10bfac: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; Priority_Control the_priority; int status; if ( !old_ceiling ) 10bfaf: 85 f6 test %esi,%esi <== NOT EXECUTED 10bfb1: 74 0b je 10bfbe <== NOT EXECUTED return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) 10bfb3: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10bfb6: 48 dec %eax <== NOT EXECUTED 10bfb7: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10bfbc: 76 0e jbe 10bfcc <== NOT EXECUTED &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); return 0; 10bfbe: bb 16 00 00 00 mov $0x16,%ebx <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10bfc3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bfc5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10bfc8: 5b pop %ebx <== NOT EXECUTED 10bfc9: 5e pop %esi <== NOT EXECUTED 10bfca: c9 leave <== NOT EXECUTED 10bfcb: c3 ret <== NOT EXECUTED /* * Must acquire the mutex before we can change it's ceiling */ status = pthread_mutex_lock( mutex ); 10bfcc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bfcf: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bfd2: e8 55 ff ff ff call 10bf2c <== NOT EXECUTED 10bfd7: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( status ) 10bfd9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bfdc: 85 c0 test %eax,%eax <== NOT EXECUTED 10bfde: 75 e3 jne 10bfc3 <== NOT EXECUTED return status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); 10bfe0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bfe3: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10bfe6: 50 push %eax <== NOT EXECUTED 10bfe7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bfea: e8 61 fd ff ff call 10bd50 <_POSIX_Mutex_Get> <== NOT EXECUTED 10bfef: 89 c1 mov %eax,%ecx <== NOT EXECUTED switch ( location ) { 10bff1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bff4: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 10bff7: 85 d2 test %edx,%edx <== NOT EXECUTED 10bff9: 75 c3 jne 10bfbe <== NOT EXECUTED case OBJECTS_LOCAL: *old_ceiling = _POSIX_Priority_From_core( 10bffb: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10c000: 89 c2 mov %eax,%edx <== NOT EXECUTED 10c002: 2b 51 60 sub 0x60(%ecx),%edx <== NOT EXECUTED 10c005: 89 16 mov %edx,(%esi) <== NOT EXECUTED the_mutex->Mutex.Attributes.priority_ceiling ); the_mutex->Mutex.Attributes.priority_ceiling = the_priority; 10c007: 2b 45 0c sub 0xc(%ebp),%eax <== NOT EXECUTED 10c00a: 89 41 60 mov %eax,0x60(%ecx) <== NOT EXECUTED _CORE_mutex_Surrender( 10c00d: 50 push %eax <== NOT EXECUTED 10c00e: 6a 00 push $0x0 <== NOT EXECUTED 10c010: ff 71 08 pushl 0x8(%ecx) <== NOT EXECUTED 10c013: 8d 41 14 lea 0x14(%ecx),%eax <== NOT EXECUTED 10c016: 50 push %eax <== NOT EXECUTED 10c017: e8 78 20 00 00 call 10e094 <_CORE_mutex_Surrender> <== NOT EXECUTED &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 10c01c: e8 33 33 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c021: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c024: eb 9d jmp 10bfc3 <== NOT EXECUTED 0010c028 : int pthread_mutex_timedlock( pthread_mutex_t *mutex, const struct timespec *abstime ) { 10c028: 55 push %ebp <== NOT EXECUTED 10c029: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c02b: 83 ec 20 sub $0x20,%esp <== 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. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10c02e: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10c031: 50 push %eax <== NOT EXECUTED 10c032: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c035: e8 aa 00 00 00 call 10c0e4 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED switch ( status ) { 10c03a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c03d: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10c040: 76 05 jbe 10c047 <== NOT EXECUTED 10c042: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10c045: 74 15 je 10c05c <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Mutex_Lock_support( 10c047: 52 push %edx <== NOT EXECUTED 10c048: ff 75 fc pushl -0x4(%ebp) <== NOT EXECUTED 10c04b: 6a 00 push $0x0 <== NOT EXECUTED 10c04d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c050: e8 eb fe ff ff call 10bf40 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED 10c055: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } } return lock_status; } 10c058: c9 leave <== NOT EXECUTED 10c059: c3 ret <== NOT EXECUTED 10c05a: 66 90 xchg %ax,%ax <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = TRUE; break; } lock_status = _POSIX_Mutex_Lock_support( 10c05c: 50 push %eax <== NOT EXECUTED 10c05d: ff 75 fc pushl -0x4(%ebp) <== NOT EXECUTED 10c060: 6a 01 push $0x1 <== NOT EXECUTED 10c062: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c065: e8 d6 fe ff ff call 10bf40 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED 10c06a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } } return lock_status; } 10c06d: c9 leave <== NOT EXECUTED 10c06e: c3 ret <== NOT EXECUTED 0010c080 : */ int pthread_mutex_trylock( pthread_mutex_t *mutex ) { 10c080: 55 push %ebp <== NOT EXECUTED 10c081: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c083: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return _POSIX_Mutex_Lock_support( mutex, FALSE, THREAD_QUEUE_WAIT_FOREVER ); 10c086: 6a 00 push $0x0 <== NOT EXECUTED 10c088: 6a 00 push $0x0 <== NOT EXECUTED 10c08a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c08d: e8 ae fe ff ff call 10bf40 <_POSIX_Mutex_Lock_support> <== NOT EXECUTED } 10c092: c9 leave <== NOT EXECUTED 10c093: c3 ret <== NOT EXECUTED 0010c094 : */ int pthread_mutex_unlock( pthread_mutex_t *mutex ) { 10c094: 55 push %ebp <== NOT EXECUTED 10c095: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c097: 53 push %ebx <== NOT EXECUTED 10c098: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; CORE_mutex_Status status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); 10c09b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10c09e: 50 push %eax <== NOT EXECUTED 10c09f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c0a2: e8 a9 fc ff ff call 10bd50 <_POSIX_Mutex_Get> <== NOT EXECUTED switch ( location ) { 10c0a7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c0aa: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 10c0ad: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10c0af: 75 27 jne 10c0d8 <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_mutex_Surrender( 10c0b1: 52 push %edx <== NOT EXECUTED 10c0b2: 6a 00 push $0x0 <== NOT EXECUTED 10c0b4: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10c0b7: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 10c0ba: 50 push %eax <== NOT EXECUTED 10c0bb: e8 d4 1f 00 00 call 10e094 <_CORE_mutex_Surrender> <== NOT EXECUTED 10c0c0: 89 c3 mov %eax,%ebx <== NOT EXECUTED &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 10c0c2: e8 8d 32 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_Mutex_Translate_core_mutex_return_code( status ); 10c0c7: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10c0ca: e8 a1 ff ff ff call 10c070 <_POSIX_Mutex_Translate_core_mutex_return_code> <== NOT EXECUTED 10c0cf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10c0d2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c0d5: c9 leave <== NOT EXECUTED 10c0d6: c3 ret <== NOT EXECUTED 10c0d7: 90 nop <== NOT EXECUTED register POSIX_Mutex_Control *the_mutex; Objects_Locations location; CORE_mutex_Status status; the_mutex = _POSIX_Mutex_Get( mutex, &location ); switch ( location ) { 10c0d8: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10c0dd: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c0e0: c9 leave <== NOT EXECUTED 10c0e1: c3 ret <== NOT EXECUTED 0010bb24 : */ int pthread_mutexattr_destroy( pthread_mutexattr_t *attr ) { 10bb24: 55 push %ebp <== NOT EXECUTED 10bb25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb27: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10bb2a: 85 c0 test %eax,%eax <== NOT EXECUTED 10bb2c: 74 12 je 10bb40 <== NOT EXECUTED 10bb2e: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10bb30: 85 d2 test %edx,%edx <== NOT EXECUTED 10bb32: 74 0c je 10bb40 <== NOT EXECUTED return EINVAL; attr->is_initialized = FALSE; 10bb34: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10bb3a: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10bb3c: c9 leave <== NOT EXECUTED 10bb3d: c3 ret <== NOT EXECUTED 10bb3e: 66 90 xchg %ax,%ax <== NOT EXECUTED { if ( !attr || !attr->is_initialized ) return EINVAL; attr->is_initialized = FALSE; return 0; 10bb40: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10bb45: c9 leave <== NOT EXECUTED 10bb46: c3 ret <== NOT EXECUTED 0010bb48 : int pthread_mutexattr_getprioceiling( const pthread_mutexattr_t *attr, int *prioceiling ) { 10bb48: 55 push %ebp <== NOT EXECUTED 10bb49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb4b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bb4e: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !prioceiling ) 10bb51: 85 c0 test %eax,%eax <== NOT EXECUTED 10bb53: 74 13 je 10bb68 <== NOT EXECUTED 10bb55: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10bb57: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bb59: 74 0d je 10bb68 <== NOT EXECUTED 10bb5b: 85 d2 test %edx,%edx <== NOT EXECUTED 10bb5d: 74 09 je 10bb68 <== NOT EXECUTED return EINVAL; *prioceiling = attr->prio_ceiling; 10bb5f: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10bb62: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10bb64: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10bb66: c9 leave <== NOT EXECUTED 10bb67: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !prioceiling ) return EINVAL; *prioceiling = attr->prio_ceiling; return 0; 10bb68: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10bb6d: c9 leave <== NOT EXECUTED 10bb6e: c3 ret <== NOT EXECUTED 0010bb70 : int pthread_mutexattr_getprotocol( const pthread_mutexattr_t *attr, int *protocol ) { 10bb70: 55 push %ebp <== NOT EXECUTED 10bb71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb73: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bb76: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !protocol ) 10bb79: 85 c0 test %eax,%eax <== NOT EXECUTED 10bb7b: 74 13 je 10bb90 <== NOT EXECUTED 10bb7d: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10bb7f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bb81: 74 0d je 10bb90 <== NOT EXECUTED 10bb83: 85 d2 test %edx,%edx <== NOT EXECUTED 10bb85: 74 09 je 10bb90 <== NOT EXECUTED return EINVAL; *protocol = attr->protocol; 10bb87: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10bb8a: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10bb8c: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10bb8e: c9 leave <== NOT EXECUTED 10bb8f: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !protocol ) return EINVAL; *protocol = attr->protocol; return 0; 10bb90: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10bb95: c9 leave <== NOT EXECUTED 10bb96: c3 ret <== NOT EXECUTED 0010bb98 : int pthread_mutexattr_getpshared( const pthread_mutexattr_t *attr, int *pshared ) { 10bb98: 55 push %ebp <== NOT EXECUTED 10bb99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb9b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bb9e: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized || !pshared ) 10bba1: 85 c0 test %eax,%eax <== NOT EXECUTED 10bba3: 74 13 je 10bbb8 <== NOT EXECUTED 10bba5: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10bba7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bba9: 74 0d je 10bbb8 <== NOT EXECUTED 10bbab: 85 d2 test %edx,%edx <== NOT EXECUTED 10bbad: 74 09 je 10bbb8 <== NOT EXECUTED return EINVAL; *pshared = attr->process_shared; 10bbaf: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10bbb2: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10bbb4: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10bbb6: c9 leave <== NOT EXECUTED 10bbb7: c3 ret <== NOT EXECUTED { if ( !attr || !attr->is_initialized || !pshared ) return EINVAL; *pshared = attr->process_shared; return 0; 10bbb8: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10bbbd: c9 leave <== NOT EXECUTED 10bbbe: c3 ret <== NOT EXECUTED 0010bbc0 : */ int pthread_mutexattr_init( pthread_mutexattr_t *attr ) { 10bbc0: 55 push %ebp <== NOT EXECUTED 10bbc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bbc3: 57 push %edi <== NOT EXECUTED 10bbc4: 56 push %esi <== NOT EXECUTED 10bbc5: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bbc8: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED if ( !attr ) 10bbcb: 85 ff test %edi,%edi <== NOT EXECUTED 10bbcd: 74 15 je 10bbe4 <== NOT EXECUTED return EINVAL; *attr = _POSIX_Mutex_Default_attributes; 10bbcf: be e8 e6 11 00 mov $0x11e6e8,%esi <== NOT EXECUTED 10bbd4: b9 05 00 00 00 mov $0x5,%ecx <== NOT EXECUTED 10bbd9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10bbdb: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10bbdd: 5a pop %edx <== NOT EXECUTED 10bbde: 5e pop %esi <== NOT EXECUTED 10bbdf: 5f pop %edi <== NOT EXECUTED 10bbe0: c9 leave <== NOT EXECUTED 10bbe1: c3 ret <== NOT EXECUTED 10bbe2: 66 90 xchg %ax,%ax <== NOT EXECUTED int pthread_mutexattr_init( pthread_mutexattr_t *attr ) { if ( !attr ) 10bbe4: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED return EINVAL; *attr = _POSIX_Mutex_Default_attributes; return 0; } 10bbe9: 5a pop %edx <== NOT EXECUTED 10bbea: 5e pop %esi <== NOT EXECUTED 10bbeb: 5f pop %edi <== NOT EXECUTED 10bbec: c9 leave <== NOT EXECUTED 10bbed: c3 ret <== NOT EXECUTED 0010bbf0 : int pthread_mutexattr_setprioceiling( pthread_mutexattr_t *attr, int prioceiling ) { 10bbf0: 55 push %ebp <== NOT EXECUTED 10bbf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bbf3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10bbf6: 85 d2 test %edx,%edx <== NOT EXECUTED 10bbf8: 74 1e je 10bc18 <== NOT EXECUTED 10bbfa: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10bbfc: 85 c0 test %eax,%eax <== NOT EXECUTED 10bbfe: 74 18 je 10bc18 <== NOT EXECUTED return EINVAL; if ( !_POSIX_Priority_Is_valid( prioceiling ) ) 10bc00: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10bc03: 48 dec %eax <== NOT EXECUTED 10bc04: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10bc09: 77 0d ja 10bc18 <== NOT EXECUTED return EINVAL; attr->prio_ceiling = prioceiling; 10bc0b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10bc0e: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED 10bc11: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10bc13: c9 leave <== NOT EXECUTED 10bc14: c3 ret <== NOT EXECUTED 10bc15: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !_POSIX_Priority_Is_valid( prioceiling ) ) return EINVAL; attr->prio_ceiling = prioceiling; return 0; 10bc18: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10bc1d: c9 leave <== NOT EXECUTED 10bc1e: c3 ret <== NOT EXECUTED 0010bc20 : int pthread_mutexattr_setprotocol( pthread_mutexattr_t *attr, int protocol ) { 10bc20: 55 push %ebp <== NOT EXECUTED 10bc21: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc23: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10bc26: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc28: 74 0c je 10bc36 <== NOT EXECUTED 10bc2a: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10bc2c: 85 d2 test %edx,%edx <== NOT EXECUTED 10bc2e: 74 06 je 10bc36 <== NOT EXECUTED return EINVAL; switch ( protocol ) { 10bc30: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) <== NOT EXECUTED 10bc34: 76 0a jbe 10bc40 <== NOT EXECUTED case PTHREAD_PRIO_NONE: case PTHREAD_PRIO_INHERIT: case PTHREAD_PRIO_PROTECT: attr->protocol = protocol; return 0; 10bc36: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10bc3b: c9 leave <== NOT EXECUTED 10bc3c: c3 ret <== NOT EXECUTED 10bc3d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED switch ( protocol ) { case PTHREAD_PRIO_NONE: case PTHREAD_PRIO_INHERIT: case PTHREAD_PRIO_PROTECT: attr->protocol = protocol; 10bc40: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10bc43: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED 10bc46: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return EINVAL; } } 10bc48: c9 leave <== NOT EXECUTED 10bc49: c3 ret <== NOT EXECUTED 0010bc4c : int pthread_mutexattr_setpshared( pthread_mutexattr_t *attr, int pshared ) { 10bc4c: 55 push %ebp <== NOT EXECUTED 10bc4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc4f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || !attr->is_initialized ) 10bc52: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc54: 74 0c je 10bc62 <== NOT EXECUTED 10bc56: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10bc58: 85 d2 test %edx,%edx <== NOT EXECUTED 10bc5a: 74 06 je 10bc62 <== NOT EXECUTED return EINVAL; switch ( pshared ) { 10bc5c: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10bc60: 76 0a jbe 10bc6c <== NOT EXECUTED case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; return 0; 10bc62: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10bc67: c9 leave <== NOT EXECUTED 10bc68: c3 ret <== NOT EXECUTED 10bc69: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return EINVAL; switch ( pshared ) { case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10bc6c: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10bc6f: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 10bc72: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return EINVAL; } } 10bc74: c9 leave <== NOT EXECUTED 10bc75: c3 ret <== NOT EXECUTED 0010b3ec : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { 10b3ec: 55 push %ebp <== NOT EXECUTED 10b3ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b3ef: 56 push %esi <== NOT EXECUTED 10b3f0: 53 push %ebx <== NOT EXECUTED 10b3f1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10b3f4: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( !once_control || !init_routine ) 10b3f7: 85 db test %ebx,%ebx <== NOT EXECUTED 10b3f9: 74 55 je 10b450 <== NOT EXECUTED 10b3fb: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b3fe: 85 c0 test %eax,%eax <== NOT EXECUTED 10b400: 74 4e je 10b450 <== NOT EXECUTED return EINVAL; if ( !once_control->init_executed ) { 10b402: 8b 73 04 mov 0x4(%ebx),%esi <== NOT EXECUTED 10b405: 85 f6 test %esi,%esi <== NOT EXECUTED 10b407: 74 0b je 10b414 <== NOT EXECUTED 10b409: 31 c0 xor %eax,%eax <== NOT EXECUTED (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); } return 0; } 10b40b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b40e: 5b pop %ebx <== NOT EXECUTED 10b40f: 5e pop %esi <== NOT EXECUTED 10b410: c9 leave <== NOT EXECUTED 10b411: c3 ret <== NOT EXECUTED 10b412: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !once_control || !init_routine ) return EINVAL; if ( !once_control->init_executed ) { rtems_mode saveMode; rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode); 10b414: 51 push %ecx <== NOT EXECUTED 10b415: 8d 75 f4 lea -0xc(%ebp),%esi <== NOT EXECUTED 10b418: 56 push %esi <== NOT EXECUTED 10b419: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 10b41e: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 10b423: e8 30 0e 00 00 call 10c258 <== NOT EXECUTED if ( !once_control->init_executed ) { 10b428: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b42b: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 10b42e: 85 d2 test %edx,%edx <== NOT EXECUTED 10b430: 74 2a je 10b45c <== NOT EXECUTED once_control->is_initialized = TRUE; once_control->init_executed = TRUE; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10b432: 50 push %eax <== NOT EXECUTED 10b433: 56 push %esi <== NOT EXECUTED 10b434: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 10b439: ff 75 f4 pushl -0xc(%ebp) <== NOT EXECUTED 10b43c: e8 17 0e 00 00 call 10c258 <== NOT EXECUTED 10b441: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b443: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 10b446: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b449: 5b pop %ebx <== NOT EXECUTED 10b44a: 5e pop %esi <== NOT EXECUTED 10b44b: c9 leave <== NOT EXECUTED 10b44c: c3 ret <== NOT EXECUTED 10b44d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !once_control->init_executed ) { once_control->is_initialized = TRUE; once_control->init_executed = TRUE; (*init_routine)(); } rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode); 10b450: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } return 0; } 10b455: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b458: 5b pop %ebx <== NOT EXECUTED 10b459: 5e pop %esi <== NOT EXECUTED 10b45a: c9 leave <== NOT EXECUTED 10b45b: c3 ret <== NOT EXECUTED 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; 10b45c: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED once_control->init_executed = TRUE; 10b462: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx) <== NOT EXECUTED (*init_routine)(); 10b469: ff 55 0c call *0xc(%ebp) <== NOT EXECUTED 10b46c: eb c4 jmp 10b432 <== NOT EXECUTED 0010aad8 : */ int pthread_rwlock_destroy( pthread_rwlock_t *rwlock ) { 10aad8: 55 push %ebp <== NOT EXECUTED 10aad9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aadb: 53 push %ebx <== NOT EXECUTED 10aadc: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10aadf: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock = NULL; Objects_Locations location; if ( !rwlock ) 10aae2: 85 d2 test %edx,%edx <== NOT EXECUTED 10aae4: 74 42 je 10ab28 <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 10aae6: 53 push %ebx <== NOT EXECUTED 10aae7: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10aaea: 50 push %eax <== NOT EXECUTED 10aaeb: ff 32 pushl (%edx) <== NOT EXECUTED 10aaed: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10aaf2: e8 55 2e 00 00 call 10d94c <_Objects_Get> <== NOT EXECUTED 10aaf7: 89 c3 mov %eax,%ebx <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10aaf9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aafc: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 10aaff: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ab01: 75 25 jne 10ab28 <== NOT EXECUTED 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 ) { 10ab03: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab06: 8d 40 10 lea 0x10(%eax),%eax <== NOT EXECUTED 10ab09: 50 push %eax <== NOT EXECUTED 10ab0a: e8 7d 3e 00 00 call 10e98c <_Thread_queue_First> <== NOT EXECUTED 10ab0f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab12: 85 c0 test %eax,%eax <== NOT EXECUTED 10ab14: 74 1e je 10ab34 <== NOT EXECUTED _Thread_Enable_dispatch(); 10ab16: e8 75 36 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ab1b: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ab20: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ab23: c9 leave <== NOT EXECUTED 10ab24: c3 ret <== NOT EXECUTED 10ab25: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object ); _POSIX_RWLock_Free( the_rwlock ); _Thread_Enable_dispatch(); return 0; 10ab28: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ab2d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ab30: c9 leave <== NOT EXECUTED 10ab31: c3 ret <== NOT EXECUTED 10ab32: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * POSIX doesn't require behavior when it is locked. */ _Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object ); 10ab34: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ab37: 53 push %ebx <== NOT EXECUTED 10ab38: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10ab3d: e8 96 29 00 00 call 10d4d8 <_Objects_Close> <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * 10ab42: 58 pop %eax <== NOT EXECUTED 10ab43: 5a pop %edx <== NOT EXECUTED 10ab44: 53 push %ebx <== NOT EXECUTED 10ab45: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10ab4a: e8 c9 2c 00 00 call 10d818 <_Objects_Free> <== NOT EXECUTED _POSIX_RWLock_Free( the_rwlock ); _Thread_Enable_dispatch(); 10ab4f: e8 3c 36 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ab54: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ab56: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab59: eb d2 jmp 10ab2d <== NOT EXECUTED 0010ab5c : int pthread_rwlock_init( pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr ) { 10ab5c: 55 push %ebp <== NOT EXECUTED 10ab5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ab5f: 56 push %esi <== NOT EXECUTED 10ab60: 53 push %ebx <== NOT EXECUTED 10ab61: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ab64: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10ab67: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED const pthread_rwlockattr_t *the_attr; /* * Error check parameters */ if ( !rwlock ) 10ab6a: 85 f6 test %esi,%esi <== NOT EXECUTED 10ab6c: 74 15 je 10ab83 <== NOT EXECUTED return EINVAL; /* * If the user passed in NULL, use the default attributes */ if ( attr ) { 10ab6e: 85 c0 test %eax,%eax <== NOT EXECUTED 10ab70: 0f 84 82 00 00 00 je 10abf8 <== NOT EXECUTED } /* * Now start error checking the attributes that we are going to use */ if ( !the_attr->is_initialized ) 10ab76: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10ab78: 85 d2 test %edx,%edx <== NOT EXECUTED 10ab7a: 74 07 je 10ab83 <== NOT EXECUTED return EINVAL; switch ( the_attr->process_shared ) { 10ab7c: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10ab7f: 85 c0 test %eax,%eax <== NOT EXECUTED 10ab81: 74 0d je 10ab90 <== NOT EXECUTED ); *rwlock = the_rwlock->Object.id; _Thread_Enable_dispatch(); return 0; 10ab83: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10ab88: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ab8b: 5b pop %ebx <== NOT EXECUTED 10ab8c: 5e pop %esi <== NOT EXECUTED 10ab8d: c9 leave <== NOT EXECUTED 10ab8e: c3 ret <== NOT EXECUTED 10ab8f: 90 nop <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10ab90: a1 18 20 12 00 mov 0x122018,%eax <== NOT EXECUTED 10ab95: 40 inc %eax <== NOT EXECUTED 10ab96: a3 18 20 12 00 mov %eax,0x122018 <== NOT EXECUTED */ /**@{*/ #ifdef __cplusplus extern "C" { #endif 10ab9b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab9e: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10aba3: e8 b0 28 00 00 call 10d458 <_Objects_Allocate> <== NOT EXECUTED 10aba8: 89 c3 mov %eax,%ebx <== NOT EXECUTED */ _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { 10abaa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10abad: 85 c0 test %eax,%eax <== NOT EXECUTED 10abaf: 74 3b je 10abec <== NOT EXECUTED _Thread_Enable_dispatch(); return EAGAIN; } _CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes ); 10abb1: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10abb4: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10abb7: 50 push %eax <== NOT EXECUTED 10abb8: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10abbb: 50 push %eax <== NOT EXECUTED 10abbc: e8 d7 21 00 00 call 10cd98 <_CORE_RWLock_Initialize> <== NOT EXECUTED 10abc1: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10abc4: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10abc7: a1 bc 22 12 00 mov 0x1222bc,%eax <== NOT EXECUTED 10abcc: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10abcf: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED &_POSIX_RWLock_Information, &the_rwlock->Object, 0 ); *rwlock = the_rwlock->Object.id; 10abd6: 89 0e mov %ecx,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10abd8: e8 b3 35 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED 10abdd: 31 c0 xor %eax,%eax <== NOT EXECUTED 10abdf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10abe2: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10abe5: 5b pop %ebx <== NOT EXECUTED 10abe6: 5e pop %esi <== NOT EXECUTED 10abe7: c9 leave <== NOT EXECUTED 10abe8: c3 ret <== NOT EXECUTED 10abe9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_rwlock = _POSIX_RWLock_Allocate(); if ( !the_rwlock ) { _Thread_Enable_dispatch(); 10abec: e8 9f 35 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED 10abf1: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 10abf6: eb 90 jmp 10ab88 <== NOT EXECUTED * If the user passed in NULL, use the default attributes */ if ( attr ) { the_attr = attr; } else { (void) pthread_rwlockattr_init( &default_attr ); 10abf8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10abfb: 8d 5d ec lea -0x14(%ebp),%ebx <== NOT EXECUTED 10abfe: 53 push %ebx <== NOT EXECUTED 10abff: e8 24 0a 00 00 call 10b628 <== NOT EXECUTED 10ac04: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10ac06: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac09: e9 68 ff ff ff jmp 10ab76 <== NOT EXECUTED 0010ac10 : */ int pthread_rwlock_rdlock( pthread_rwlock_t *rwlock ) { 10ac10: 55 push %ebp <== NOT EXECUTED 10ac11: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac13: 53 push %ebx <== NOT EXECUTED 10ac14: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10ac17: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 10ac1a: 85 db test %ebx,%ebx <== NOT EXECUTED 10ac1c: 74 1b je 10ac39 <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 10ac1e: 51 push %ecx <== NOT EXECUTED 10ac1f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10ac22: 50 push %eax <== NOT EXECUTED 10ac23: ff 33 pushl (%ebx) <== NOT EXECUTED 10ac25: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10ac2a: e8 1d 2d 00 00 call 10d94c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10ac2f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac32: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10ac35: 85 d2 test %edx,%edx <== NOT EXECUTED 10ac37: 74 0b je 10ac44 <== NOT EXECUTED 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 10ac39: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ac3e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ac41: c9 leave <== NOT EXECUTED 10ac42: c3 ret <== NOT EXECUTED 10ac43: 90 nop <== NOT EXECUTED the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10ac44: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac47: 6a 00 push $0x0 <== NOT EXECUTED 10ac49: 6a 00 push $0x0 <== NOT EXECUTED 10ac4b: 6a 01 push $0x1 <== NOT EXECUTED 10ac4d: ff 33 pushl (%ebx) <== NOT EXECUTED 10ac4f: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10ac52: 50 push %eax <== NOT EXECUTED 10ac53: e8 74 21 00 00 call 10cdcc <_CORE_RWLock_Obtain_for_reading> <== NOT EXECUTED TRUE, /* we are willing to wait forever */ 0, NULL ); _Thread_Enable_dispatch(); 10ac58: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10ac5b: e8 30 35 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( 10ac60: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac63: a1 dc 20 12 00 mov 0x1220dc,%eax <== NOT EXECUTED 10ac68: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10ac6b: e8 90 01 00 00 call 10ae00 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 10ac70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ac73: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ac76: c9 leave <== NOT EXECUTED 10ac77: c3 ret <== NOT EXECUTED 0010ac78 : int pthread_rwlock_timedrdlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10ac78: 55 push %ebp <== NOT EXECUTED 10ac79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac7b: 57 push %edi <== NOT EXECUTED 10ac7c: 56 push %esi <== NOT EXECUTED 10ac7d: 53 push %ebx <== NOT EXECUTED 10ac7e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10ac81: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Objects_Locations location; Watchdog_Interval ticks; bool do_wait; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 10ac84: 85 f6 test %esi,%esi <== NOT EXECUTED 10ac86: 74 78 je 10ad00 <== 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. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10ac88: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ac8b: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10ac8e: 50 push %eax <== NOT EXECUTED 10ac8f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10ac92: e8 7d 63 00 00 call 111014 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 10ac97: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch (status) { 10ac99: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ac9c: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10ac9f: 76 6f jbe 10ad10 <== NOT EXECUTED 10aca1: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10aca4: 75 05 jne 10acab <== NOT EXECUTED 10aca6: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED 10acab: 52 push %edx <== NOT EXECUTED 10acac: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10acaf: 50 push %eax <== NOT EXECUTED 10acb0: ff 36 pushl (%esi) <== NOT EXECUTED 10acb2: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10acb7: e8 90 2c 00 00 call 10d94c <_Objects_Get> <== NOT EXECUTED 10acbc: 89 c2 mov %eax,%edx <== NOT EXECUTED do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10acbe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10acc1: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10acc4: 85 c0 test %eax,%eax <== NOT EXECUTED 10acc6: 75 38 jne 10ad00 <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10acc8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10accb: 6a 00 push $0x0 <== NOT EXECUTED 10accd: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10acd0: 89 f9 mov %edi,%ecx <== NOT EXECUTED 10acd2: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 10acd5: 50 push %eax <== NOT EXECUTED 10acd6: ff 36 pushl (%esi) <== NOT EXECUTED 10acd8: 8d 42 10 lea 0x10(%edx),%eax <== NOT EXECUTED 10acdb: 50 push %eax <== NOT EXECUTED 10acdc: e8 eb 20 00 00 call 10cdcc <_CORE_RWLock_Obtain_for_reading> <== NOT EXECUTED do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10ace1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10ace4: e8 a7 34 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( !do_wait && 10ace9: 89 f8 mov %edi,%eax <== NOT EXECUTED 10aceb: 84 c0 test %al,%al <== NOT EXECUTED 10aced: 75 25 jne 10ad14 <== NOT EXECUTED 10acef: a1 dc 20 12 00 mov 0x1220dc,%eax <== NOT EXECUTED 10acf4: 83 78 34 02 cmpl $0x2,0x34(%eax) <== NOT EXECUTED 10acf8: 75 1f jne 10ad19 <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 10acfa: 85 db test %ebx,%ebx <== NOT EXECUTED 10acfc: 75 32 jne 10ad30 <== NOT EXECUTED 10acfe: 66 90 xchg %ax,%ax <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10ad00: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ad05: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ad08: 5b pop %ebx <== NOT EXECUTED 10ad09: 5e pop %esi <== NOT EXECUTED 10ad0a: 5f pop %edi <== NOT EXECUTED 10ad0b: c9 leave <== NOT EXECUTED 10ad0c: c3 ret <== NOT EXECUTED 10ad0d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * 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 ); switch (status) { 10ad10: 31 ff xor %edi,%edi <== NOT EXECUTED 10ad12: eb 97 jmp 10acab <== NOT EXECUTED 10ad14: a1 dc 20 12 00 mov 0x1220dc,%eax <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10ad19: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad1c: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10ad1f: e8 dc 00 00 00 call 10ae00 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 10ad24: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ad27: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ad2a: 5b pop %ebx <== NOT EXECUTED 10ad2b: 5e pop %esi <== NOT EXECUTED 10ad2c: 5f pop %edi <== NOT EXECUTED 10ad2d: c9 leave <== NOT EXECUTED 10ad2e: c3 ret <== NOT EXECUTED 10ad2f: 90 nop <== NOT EXECUTED ); _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 10ad30: 83 fb 02 cmp $0x2,%ebx <== NOT EXECUTED 10ad33: 77 e4 ja 10ad19 <== NOT EXECUTED 10ad35: b8 74 00 00 00 mov $0x74,%eax <== NOT EXECUTED 10ad3a: eb c9 jmp 10ad05 <== NOT EXECUTED 0010ad3c : int pthread_rwlock_timedwrlock( pthread_rwlock_t *rwlock, const struct timespec *abstime ) { 10ad3c: 55 push %ebp <== NOT EXECUTED 10ad3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad3f: 57 push %edi <== NOT EXECUTED 10ad40: 56 push %esi <== NOT EXECUTED 10ad41: 53 push %ebx <== NOT EXECUTED 10ad42: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10ad45: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Objects_Locations location; Watchdog_Interval ticks; bool do_wait; POSIX_Absolute_timeout_conversion_results_t status; if ( !rwlock ) 10ad48: 85 f6 test %esi,%esi <== NOT EXECUTED 10ad4a: 74 78 je 10adc4 <== 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. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10ad4c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ad4f: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10ad52: 50 push %eax <== NOT EXECUTED 10ad53: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10ad56: e8 b9 62 00 00 call 111014 <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED 10ad5b: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch (status) { 10ad5d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad60: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10ad63: 76 6f jbe 10add4 <== NOT EXECUTED 10ad65: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10ad68: 75 05 jne 10ad6f <== NOT EXECUTED 10ad6a: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED 10ad6f: 52 push %edx <== NOT EXECUTED 10ad70: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10ad73: 50 push %eax <== NOT EXECUTED 10ad74: ff 36 pushl (%esi) <== NOT EXECUTED 10ad76: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10ad7b: e8 cc 2b 00 00 call 10d94c <_Objects_Get> <== NOT EXECUTED 10ad80: 89 c2 mov %eax,%edx <== NOT EXECUTED do_wait = TRUE; break; } the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10ad82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ad85: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10ad88: 85 c0 test %eax,%eax <== NOT EXECUTED 10ad8a: 75 38 jne 10adc4 <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 10ad8c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad8f: 6a 00 push $0x0 <== NOT EXECUTED 10ad91: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10ad94: 89 f9 mov %edi,%ecx <== NOT EXECUTED 10ad96: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 10ad99: 50 push %eax <== NOT EXECUTED 10ad9a: ff 36 pushl (%esi) <== NOT EXECUTED 10ad9c: 8d 42 10 lea 0x10(%edx),%eax <== NOT EXECUTED 10ad9f: 50 push %eax <== NOT EXECUTED 10ada0: e8 ef 20 00 00 call 10ce94 <_CORE_RWLock_Obtain_for_writing> <== NOT EXECUTED do_wait, ticks, NULL ); _Thread_Enable_dispatch(); 10ada5: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10ada8: e8 e3 33 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( !do_wait && 10adad: 89 f8 mov %edi,%eax <== NOT EXECUTED 10adaf: 84 c0 test %al,%al <== NOT EXECUTED 10adb1: 75 25 jne 10add8 <== NOT EXECUTED 10adb3: a1 dc 20 12 00 mov 0x1220dc,%eax <== NOT EXECUTED 10adb8: 83 78 34 02 cmpl $0x2,0x34(%eax) <== NOT EXECUTED 10adbc: 75 1f jne 10addd <== NOT EXECUTED (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 10adbe: 85 db test %ebx,%ebx <== NOT EXECUTED 10adc0: 75 32 jne 10adf4 <== NOT EXECUTED 10adc2: 66 90 xchg %ax,%ax <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10adc4: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10adc9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10adcc: 5b pop %ebx <== NOT EXECUTED 10adcd: 5e pop %esi <== NOT EXECUTED 10adce: 5f pop %edi <== NOT EXECUTED 10adcf: c9 leave <== NOT EXECUTED 10add0: c3 ret <== NOT EXECUTED 10add1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * 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 ); switch (status) { 10add4: 31 ff xor %edi,%edi <== NOT EXECUTED 10add6: eb 97 jmp 10ad6f <== NOT EXECUTED 10add8: a1 dc 20 12 00 mov 0x1220dc,%eax <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: break; } } return _POSIX_RWLock_Translate_core_RWLock_return_code( 10addd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ade0: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10ade3: e8 18 00 00 00 call 10ae00 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 10ade8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10adeb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10adee: 5b pop %ebx <== NOT EXECUTED 10adef: 5e pop %esi <== NOT EXECUTED 10adf0: 5f pop %edi <== NOT EXECUTED 10adf1: c9 leave <== NOT EXECUTED 10adf2: c3 ret <== NOT EXECUTED 10adf3: 90 nop <== NOT EXECUTED ); _Thread_Enable_dispatch(); if ( !do_wait && (_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) { switch (status) { 10adf4: 83 fb 02 cmp $0x2,%ebx <== NOT EXECUTED 10adf7: 77 e4 ja 10addd <== NOT EXECUTED 10adf9: b8 74 00 00 00 mov $0x74,%eax <== NOT EXECUTED 10adfe: eb c9 jmp 10adc9 <== NOT EXECUTED 0010ae10 : */ int pthread_rwlock_tryrdlock( pthread_rwlock_t *rwlock ) { 10ae10: 55 push %ebp <== NOT EXECUTED 10ae11: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae13: 53 push %ebx <== NOT EXECUTED 10ae14: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10ae17: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 10ae1a: 85 db test %ebx,%ebx <== NOT EXECUTED 10ae1c: 74 1b je 10ae39 <== NOT EXECUTED 10ae1e: 51 push %ecx <== NOT EXECUTED 10ae1f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10ae22: 50 push %eax <== NOT EXECUTED 10ae23: ff 33 pushl (%ebx) <== NOT EXECUTED 10ae25: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10ae2a: e8 1d 2b 00 00 call 10d94c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10ae2f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae32: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10ae35: 85 d2 test %edx,%edx <== NOT EXECUTED 10ae37: 74 0b je 10ae44 <== NOT EXECUTED NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 10ae39: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ae3e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ae41: c9 leave <== NOT EXECUTED 10ae42: c3 ret <== NOT EXECUTED 10ae43: 90 nop <== NOT EXECUTED the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_reading( 10ae44: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae47: 6a 00 push $0x0 <== NOT EXECUTED 10ae49: 6a 00 push $0x0 <== NOT EXECUTED 10ae4b: 6a 00 push $0x0 <== NOT EXECUTED 10ae4d: ff 33 pushl (%ebx) <== NOT EXECUTED 10ae4f: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10ae52: 50 push %eax <== NOT EXECUTED 10ae53: e8 74 1f 00 00 call 10cdcc <_CORE_RWLock_Obtain_for_reading> <== NOT EXECUTED 0, NULL ); _Thread_Enable_dispatch(); 10ae58: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10ae5b: e8 30 33 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( 10ae60: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae63: a1 dc 20 12 00 mov 0x1220dc,%eax <== NOT EXECUTED 10ae68: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10ae6b: e8 90 ff ff ff call 10ae00 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 10ae70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10ae73: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ae76: c9 leave <== NOT EXECUTED 10ae77: c3 ret <== NOT EXECUTED 0010ae78 : */ int pthread_rwlock_trywrlock( pthread_rwlock_t *rwlock ) { 10ae78: 55 push %ebp <== NOT EXECUTED 10ae79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ae7b: 53 push %ebx <== NOT EXECUTED 10ae7c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10ae7f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 10ae82: 85 db test %ebx,%ebx <== NOT EXECUTED 10ae84: 74 1b je 10aea1 <== NOT EXECUTED 10ae86: 51 push %ecx <== NOT EXECUTED 10ae87: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10ae8a: 50 push %eax <== NOT EXECUTED 10ae8b: ff 33 pushl (%ebx) <== NOT EXECUTED 10ae8d: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10ae92: e8 b5 2a 00 00 call 10d94c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10ae97: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae9a: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10ae9d: 85 d2 test %edx,%edx <== NOT EXECUTED 10ae9f: 74 0b je 10aeac <== NOT EXECUTED 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 10aea1: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10aea6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aea9: c9 leave <== NOT EXECUTED 10aeaa: c3 ret <== NOT EXECUTED 10aeab: 90 nop <== NOT EXECUTED the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 10aeac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aeaf: 6a 00 push $0x0 <== NOT EXECUTED 10aeb1: 6a 00 push $0x0 <== NOT EXECUTED 10aeb3: 6a 00 push $0x0 <== NOT EXECUTED 10aeb5: ff 33 pushl (%ebx) <== NOT EXECUTED 10aeb7: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10aeba: 50 push %eax <== NOT EXECUTED 10aebb: e8 d4 1f 00 00 call 10ce94 <_CORE_RWLock_Obtain_for_writing> <== NOT EXECUTED FALSE, /* we are not willing to wait */ 0, NULL ); _Thread_Enable_dispatch(); 10aec0: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10aec3: e8 c8 32 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( 10aec8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aecb: a1 dc 20 12 00 mov 0x1220dc,%eax <== NOT EXECUTED 10aed0: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10aed3: e8 28 ff ff ff call 10ae00 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 10aed8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10aedb: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aede: c9 leave <== NOT EXECUTED 10aedf: c3 ret <== NOT EXECUTED 0010aee0 : */ int pthread_rwlock_unlock( pthread_rwlock_t *rwlock ) { 10aee0: 55 push %ebp <== NOT EXECUTED 10aee1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aee3: 53 push %ebx <== NOT EXECUTED 10aee4: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10aee7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock; Objects_Locations location; CORE_RWLock_Status status; if ( !rwlock ) 10aeea: 85 d2 test %edx,%edx <== NOT EXECUTED 10aeec: 74 1b je 10af09 <== NOT EXECUTED 10aeee: 51 push %ecx <== NOT EXECUTED 10aeef: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10aef2: 50 push %eax <== NOT EXECUTED 10aef3: ff 32 pushl (%edx) <== NOT EXECUTED 10aef5: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10aefa: e8 4d 2a 00 00 call 10d94c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10aeff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af02: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10af05: 85 d2 test %edx,%edx <== NOT EXECUTED 10af07: 74 0b je 10af14 <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_RWLock_Release( &the_rwlock->RWLock ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); 10af09: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10af0e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10af11: c9 leave <== NOT EXECUTED 10af12: c3 ret <== NOT EXECUTED 10af13: 90 nop <== NOT EXECUTED the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { case OBJECTS_LOCAL: status = _CORE_RWLock_Release( &the_rwlock->RWLock ); 10af14: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af17: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10af1a: 50 push %eax <== NOT EXECUTED 10af1b: e8 f4 1f 00 00 call 10cf14 <_CORE_RWLock_Release> <== NOT EXECUTED 10af20: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Enable_dispatch(); 10af22: e8 69 32 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( status ); 10af27: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10af2a: e8 d1 fe ff ff call 10ae00 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 10af2f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10af32: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10af35: c9 leave <== NOT EXECUTED 10af36: c3 ret <== NOT EXECUTED 0010af38 : */ int pthread_rwlock_wrlock( pthread_rwlock_t *rwlock ) { 10af38: 55 push %ebp <== NOT EXECUTED 10af39: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10af3b: 53 push %ebx <== NOT EXECUTED 10af3c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10af3f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED POSIX_RWLock_Control *the_rwlock; Objects_Locations location; if ( !rwlock ) 10af42: 85 db test %ebx,%ebx <== NOT EXECUTED 10af44: 74 1b je 10af61 <== NOT EXECUTED 10af46: 51 push %ecx <== NOT EXECUTED 10af47: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10af4a: 50 push %eax <== NOT EXECUTED 10af4b: ff 33 pushl (%ebx) <== NOT EXECUTED 10af4d: 68 a0 22 12 00 push $0x1222a0 <== NOT EXECUTED 10af52: e8 f5 29 00 00 call 10d94c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { 10af57: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10af5a: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10af5d: 85 d2 test %edx,%edx <== NOT EXECUTED 10af5f: 74 0b je 10af6c <== NOT EXECUTED 0, NULL ); _Thread_Enable_dispatch(); return _POSIX_RWLock_Translate_core_RWLock_return_code( 10af61: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10af66: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10af69: c9 leave <== NOT EXECUTED 10af6a: c3 ret <== NOT EXECUTED 10af6b: 90 nop <== NOT EXECUTED the_rwlock = _POSIX_RWLock_Get( rwlock, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_RWLock_Obtain_for_writing( 10af6c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af6f: 6a 00 push $0x0 <== NOT EXECUTED 10af71: 6a 00 push $0x0 <== NOT EXECUTED 10af73: 6a 01 push $0x1 <== NOT EXECUTED 10af75: ff 33 pushl (%ebx) <== NOT EXECUTED 10af77: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10af7a: 50 push %eax <== NOT EXECUTED 10af7b: e8 14 1f 00 00 call 10ce94 <_CORE_RWLock_Obtain_for_writing> <== NOT EXECUTED TRUE, /* do not timeout -- wait forever */ 0, NULL ); _Thread_Enable_dispatch(); 10af80: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10af83: e8 08 32 00 00 call 10e190 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_RWLock_Translate_core_RWLock_return_code( 10af88: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10af8b: a1 dc 20 12 00 mov 0x1220dc,%eax <== NOT EXECUTED 10af90: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10af93: e8 68 fe ff ff call 10ae00 <_POSIX_RWLock_Translate_core_RWLock_return_code> <== NOT EXECUTED 10af98: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10af9b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10af9e: c9 leave <== NOT EXECUTED 10af9f: c3 ret <== NOT EXECUTED 0010b5e0 : */ int pthread_rwlockattr_destroy( pthread_rwlockattr_t *attr ) { 10b5e0: 55 push %ebp <== NOT EXECUTED 10b5e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b5e3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr || attr->is_initialized == FALSE ) 10b5e6: 85 c0 test %eax,%eax <== NOT EXECUTED 10b5e8: 74 12 je 10b5fc <== NOT EXECUTED 10b5ea: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10b5ec: 85 d2 test %edx,%edx <== NOT EXECUTED 10b5ee: 74 0c je 10b5fc <== NOT EXECUTED return EINVAL; attr->is_initialized = FALSE; 10b5f0: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10b5f6: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10b5f8: c9 leave <== NOT EXECUTED 10b5f9: c3 ret <== NOT EXECUTED 10b5fa: 66 90 xchg %ax,%ax <== NOT EXECUTED { if ( !attr || attr->is_initialized == FALSE ) return EINVAL; attr->is_initialized = FALSE; return 0; 10b5fc: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10b601: c9 leave <== NOT EXECUTED 10b602: c3 ret <== NOT EXECUTED 0010b604 : int pthread_rwlockattr_getpshared( const pthread_rwlockattr_t *attr, int *pshared ) { 10b604: 55 push %ebp <== NOT EXECUTED 10b605: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b607: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10b60a: 85 c0 test %eax,%eax <== NOT EXECUTED 10b60c: 74 12 je 10b620 <== NOT EXECUTED return EINVAL; if ( !attr->is_initialized ) 10b60e: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10b610: 85 d2 test %edx,%edx <== NOT EXECUTED 10b612: 74 0c je 10b620 <== NOT EXECUTED return EINVAL; *pshared = attr->process_shared; 10b614: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10b617: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10b61a: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10b61c: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10b61e: c9 leave <== NOT EXECUTED 10b61f: c3 ret <== NOT EXECUTED if ( !attr->is_initialized ) return EINVAL; *pshared = attr->process_shared; return 0; 10b620: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10b625: c9 leave <== NOT EXECUTED 10b626: c3 ret <== NOT EXECUTED 0010b628 : */ int pthread_rwlockattr_init( pthread_rwlockattr_t *attr ) { 10b628: 55 push %ebp <== NOT EXECUTED 10b629: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b62b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10b62e: 85 c0 test %eax,%eax <== NOT EXECUTED 10b630: 74 12 je 10b644 <== NOT EXECUTED return EINVAL; attr->is_initialized = TRUE; 10b632: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED attr->process_shared = PTHREAD_PROCESS_PRIVATE; 10b638: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED 10b63f: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10b641: c9 leave <== NOT EXECUTED 10b642: c3 ret <== NOT EXECUTED 10b643: 90 nop <== NOT EXECUTED int pthread_rwlockattr_init( pthread_rwlockattr_t *attr ) { if ( !attr ) 10b644: b0 16 mov $0x16,%al <== NOT EXECUTED return EINVAL; attr->is_initialized = TRUE; attr->process_shared = PTHREAD_PROCESS_PRIVATE; return 0; } 10b646: c9 leave <== NOT EXECUTED 10b647: c3 ret <== NOT EXECUTED 0010b648 : int pthread_rwlockattr_setpshared( pthread_rwlockattr_t *attr, int pshared ) { 10b648: 55 push %ebp <== NOT EXECUTED 10b649: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b64b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !attr ) 10b64e: 85 c0 test %eax,%eax <== NOT EXECUTED 10b650: 74 0c je 10b65e <== NOT EXECUTED return EINVAL; if ( !attr->is_initialized ) 10b652: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10b654: 85 d2 test %edx,%edx <== NOT EXECUTED 10b656: 74 06 je 10b65e <== NOT EXECUTED return EINVAL; switch ( pshared ) { 10b658: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10b65c: 76 0a jbe 10b668 <== NOT EXECUTED case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; return 0; 10b65e: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED default: return EINVAL; } } 10b663: c9 leave <== NOT EXECUTED 10b664: c3 ret <== NOT EXECUTED 10b665: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return EINVAL; switch ( pshared ) { case PTHREAD_PROCESS_SHARED: case PTHREAD_PROCESS_PRIVATE: attr->process_shared = pshared; 10b668: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10b66b: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 10b66e: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; default: return EINVAL; } } 10b670: c9 leave <== NOT EXECUTED 10b671: c3 ret <== NOT EXECUTED 00122050 : #include #include pthread_t pthread_self( void ) { 122050: 55 push %ebp <== NOT EXECUTED 122051: 89 e5 mov %esp,%ebp <== NOT EXECUTED 122053: a1 7c dd 12 00 mov 0x12dd7c,%eax <== NOT EXECUTED 122058: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED return _Thread_Executing->Object.id; } 12205b: c9 leave <== NOT EXECUTED 12205c: c3 ret <== NOT EXECUTED 0010a388 : int pthread_setcancelstate( int state, int *oldstate ) { 10a388: 55 push %ebp <== NOT EXECUTED 10a389: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a38b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED * 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() ) 10a38e: a1 b8 22 12 00 mov 0x1222b8,%eax <== NOT EXECUTED 10a393: 85 c0 test %eax,%eax <== NOT EXECUTED 10a395: 75 55 jne 10a3ec <== NOT EXECUTED return EPROTO; if ( !oldstate ) 10a397: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10a39a: 85 d2 test %edx,%edx <== NOT EXECUTED 10a39c: 74 06 je 10a3a4 <== NOT EXECUTED return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) 10a39e: 83 7d 08 01 cmpl $0x1,0x8(%ebp) <== NOT EXECUTED 10a3a2: 76 08 jbe 10a3ac <== NOT EXECUTED if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a3a4: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); return 0; } 10a3a9: c9 leave <== NOT EXECUTED 10a3aa: c3 ret <== NOT EXECUTED 10a3ab: 90 nop <== NOT EXECUTED return EINVAL; if ( state != PTHREAD_CANCEL_ENABLE && state != PTHREAD_CANCEL_DISABLE ) return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a3ac: a1 dc 22 12 00 mov 0x1222dc,%eax <== NOT EXECUTED 10a3b1: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a3b7: a1 18 22 12 00 mov 0x122218,%eax <== NOT EXECUTED 10a3bc: 40 inc %eax <== NOT EXECUTED 10a3bd: a3 18 22 12 00 mov %eax,0x122218 <== NOT EXECUTED _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; 10a3c2: 8b 82 cc 00 00 00 mov 0xcc(%edx),%eax <== NOT EXECUTED 10a3c8: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10a3cb: 89 01 mov %eax,(%ecx) <== NOT EXECUTED thread_support->cancelability_state = state; 10a3cd: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a3d0: 89 82 cc 00 00 00 mov %eax,0xcc(%edx) <== NOT EXECUTED if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10a3d6: 85 c0 test %eax,%eax <== NOT EXECUTED 10a3d8: 75 09 jne 10a3e3 <== NOT EXECUTED 10a3da: 83 ba d0 00 00 00 01 cmpl $0x1,0xd0(%edx) <== NOT EXECUTED 10a3e1: 74 11 je 10a3f4 <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a3e3: e8 84 29 00 00 call 10cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a3e8: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); return 0; } 10a3ea: c9 leave <== NOT EXECUTED 10a3eb: c3 ret <== NOT EXECUTED * 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() ) 10a3ec: b8 47 00 00 00 mov $0x47,%eax <== NOT EXECUTED _Thread_Enable_dispatch(); if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); return 0; } 10a3f1: c9 leave <== NOT EXECUTED 10a3f2: c3 ret <== NOT EXECUTED 10a3f3: 90 nop <== NOT EXECUTED _Thread_Disable_dispatch(); *oldstate = thread_support->cancelability_state; thread_support->cancelability_state = state; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10a3f4: 8b 82 d4 00 00 00 mov 0xd4(%edx),%eax <== NOT EXECUTED 10a3fa: 85 c0 test %eax,%eax <== NOT EXECUTED 10a3fc: 74 e5 je 10a3e3 <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a3fe: e8 69 29 00 00 call 10cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10a403: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a406: 6a ff push $0xffffffff <== NOT EXECUTED 10a408: ff 35 dc 22 12 00 pushl 0x1222dc <== NOT EXECUTED 10a40e: e8 55 fb ff ff call 109f68 <_POSIX_Thread_Exit> <== NOT EXECUTED 10a413: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a415: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10a418: c9 leave <== NOT EXECUTED 10a419: c3 ret <== NOT EXECUTED 0010a41c : int pthread_setcanceltype( int type, int *oldtype ) { 10a41c: 55 push %ebp <== NOT EXECUTED 10a41d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a41f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED * 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() ) 10a422: a1 b8 22 12 00 mov 0x1222b8,%eax <== NOT EXECUTED 10a427: 85 c0 test %eax,%eax <== NOT EXECUTED 10a429: 75 55 jne 10a480 <== NOT EXECUTED return EPROTO; if ( !oldtype ) 10a42b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a42e: 85 c0 test %eax,%eax <== NOT EXECUTED 10a430: 74 06 je 10a438 <== NOT EXECUTED return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) 10a432: 83 7d 08 01 cmpl $0x1,0x8(%ebp) <== NOT EXECUTED 10a436: 76 08 jbe 10a440 <== NOT EXECUTED if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a438: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); return 0; } 10a43d: c9 leave <== NOT EXECUTED 10a43e: c3 ret <== NOT EXECUTED 10a43f: 90 nop <== NOT EXECUTED return EINVAL; if ( type != PTHREAD_CANCEL_DEFERRED && type != PTHREAD_CANCEL_ASYNCHRONOUS ) return EINVAL; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a440: a1 dc 22 12 00 mov 0x1222dc,%eax <== NOT EXECUTED 10a445: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED 10a44b: a1 18 22 12 00 mov 0x122218,%eax <== NOT EXECUTED 10a450: 40 inc %eax <== NOT EXECUTED 10a451: a3 18 22 12 00 mov %eax,0x122218 <== NOT EXECUTED _Thread_Disable_dispatch(); *oldtype = thread_support->cancelability_type; 10a456: 8b 82 d0 00 00 00 mov 0xd0(%edx),%eax <== NOT EXECUTED 10a45c: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10a45f: 89 01 mov %eax,(%ecx) <== NOT EXECUTED thread_support->cancelability_type = type; 10a461: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a464: 89 82 d0 00 00 00 mov %eax,0xd0(%edx) <== NOT EXECUTED if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10a46a: 8b 8a cc 00 00 00 mov 0xcc(%edx),%ecx <== NOT EXECUTED 10a470: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a472: 75 03 jne 10a477 <== NOT EXECUTED 10a474: 48 dec %eax <== NOT EXECUTED 10a475: 74 11 je 10a488 <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a477: e8 f0 28 00 00 call 10cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a47c: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); return 0; } 10a47e: c9 leave <== NOT EXECUTED 10a47f: c3 ret <== NOT EXECUTED * 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() ) 10a480: b8 47 00 00 00 mov $0x47,%eax <== NOT EXECUTED _Thread_Enable_dispatch(); if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); return 0; } 10a485: c9 leave <== NOT EXECUTED 10a486: c3 ret <== NOT EXECUTED 10a487: 90 nop <== NOT EXECUTED _Thread_Disable_dispatch(); *oldtype = thread_support->cancelability_type; thread_support->cancelability_type = type; if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10a488: 8b 82 d4 00 00 00 mov 0xd4(%edx),%eax <== NOT EXECUTED 10a48e: 85 c0 test %eax,%eax <== NOT EXECUTED 10a490: 74 e5 je 10a477 <== NOT EXECUTED thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a492: e8 d5 28 00 00 call 10cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10a497: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a49a: 6a ff push $0xffffffff <== NOT EXECUTED 10a49c: ff 35 dc 22 12 00 pushl 0x1222dc <== NOT EXECUTED 10a4a2: e8 c1 fa ff ff call 109f68 <_POSIX_Thread_Exit> <== NOT EXECUTED 10a4a7: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a4a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10a4ac: c9 leave <== NOT EXECUTED 10a4ad: c3 ret <== NOT EXECUTED 0010c938 : int pthread_setschedparam( pthread_t thread, int policy, struct sched_param *param ) { 10c938: 55 push %ebp <== NOT EXECUTED 10c939: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c93b: 57 push %edi <== NOT EXECUTED 10c93c: 56 push %esi <== NOT EXECUTED 10c93d: 53 push %ebx <== NOT EXECUTED 10c93e: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED /* * Check all the parameters */ if ( !param ) 10c941: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10c944: 85 c0 test %eax,%eax <== NOT EXECUTED 10c946: 74 29 je 10c971 <== NOT EXECUTED return EINVAL; if ( !_POSIX_Priority_Is_valid( param->sched_priority ) ) 10c948: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10c94b: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10c94d: 48 dec %eax <== NOT EXECUTED 10c94e: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10c953: 77 1c ja 10c971 <== NOT EXECUTED return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 10c955: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10c959: 74 25 je 10c980 <== NOT EXECUTED 10c95b: 0f 8e 33 01 00 00 jle 10ca94 <== NOT EXECUTED 10c961: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) <== NOT EXECUTED 10c965: 0f 84 15 01 00 00 je 10ca80 <== NOT EXECUTED 10c96b: 83 7d 0c 03 cmpl $0x3,0xc(%ebp) <== NOT EXECUTED 10c96f: 74 4b je 10c9bc <== NOT EXECUTED _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); break; } _Thread_Enable_dispatch(); return 0; 10c971: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10c976: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c979: 5b pop %ebx <== NOT EXECUTED 10c97a: 5e pop %esi <== NOT EXECUTED 10c97b: 5f pop %edi <== NOT EXECUTED 10c97c: c9 leave <== NOT EXECUTED 10c97d: c3 ret <== NOT EXECUTED 10c97e: 66 90 xchg %ax,%ax <== NOT EXECUTED return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 10c980: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED 10c987: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10c98e: 50 push %eax <== NOT EXECUTED 10c98f: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c992: 50 push %eax <== NOT EXECUTED 10c993: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c996: 68 60 54 12 00 push $0x125460 <== NOT EXECUTED 10c99b: e8 70 21 00 00 call 10eb10 <_Objects_Get> <== NOT EXECUTED 10c9a0: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED /* * Actually change the scheduling policy and parameters */ the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { 10c9a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c9a6: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 10c9a9: 85 ff test %edi,%edi <== NOT EXECUTED 10c9ab: 74 53 je 10ca00 <== NOT EXECUTED 10c9ad: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10c9b2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c9b5: 5b pop %ebx <== NOT EXECUTED 10c9b6: 5e pop %esi <== NOT EXECUTED 10c9b7: 5f pop %edi <== NOT EXECUTED 10c9b8: c9 leave <== NOT EXECUTED 10c9b9: c3 ret <== NOT EXECUTED 10c9ba: 66 90 xchg %ax,%ax <== NOT EXECUTED 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 ) < 10c9bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c9bf: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10c9c2: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 10c9c5: 50 push %eax <== NOT EXECUTED 10c9c6: e8 79 36 00 00 call 110044 <_Timespec_To_ticks> <== NOT EXECUTED 10c9cb: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10c9cd: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10c9d0: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10c9d3: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10c9d6: e8 69 36 00 00 call 110044 <_Timespec_To_ticks> <== NOT EXECUTED 10c9db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c9de: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10c9e0: 72 8f jb 10c971 <== NOT EXECUTED _Timespec_To_ticks( ¶m->ss_initial_budget ) ) return EINVAL; if ( !_POSIX_Priority_Is_valid( param->ss_low_priority ) ) 10c9e2: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10c9e5: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10c9e8: 48 dec %eax <== NOT EXECUTED 10c9e9: 3d fd 00 00 00 cmp $0xfd,%eax <== NOT EXECUTED 10c9ee: 77 81 ja 10c971 <== NOT EXECUTED 10c9f0: c7 45 dc 03 00 00 00 movl $0x3,-0x24(%ebp) <== NOT EXECUTED 10c9f7: c7 45 e0 5c c8 10 00 movl $0x10c85c,-0x20(%ebp) <== NOT EXECUTED 10c9fe: eb 8e jmp 10c98e <== NOT EXECUTED the_thread = _POSIX_Threads_Get( thread, &location ); switch ( location ) { case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10ca00: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10ca03: 8b 98 f8 00 00 00 mov 0xf8(%eax),%ebx <== NOT EXECUTED if ( api->schedpolicy == SCHED_SPORADIC ) 10ca09: 83 7b 7c 03 cmpl $0x3,0x7c(%ebx) <== NOT EXECUTED 10ca0d: 0f 84 d5 00 00 00 je 10cae8 <== NOT EXECUTED (void) _Watchdog_Remove( &api->Sporadic_timer ); api->schedpolicy = policy; 10ca13: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10ca16: 89 53 7c mov %edx,0x7c(%ebx) <== NOT EXECUTED api->schedparam = *param; 10ca19: 8d bb 80 00 00 00 lea 0x80(%ebx),%edi <== NOT EXECUTED 10ca1f: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10ca24: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10ca27: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED the_thread->budget_algorithm = budget_algorithm; 10ca29: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10ca2c: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10ca2f: 89 50 7c mov %edx,0x7c(%eax) <== NOT EXECUTED the_thread->budget_callout = budget_callout; 10ca32: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 10ca35: 89 b0 80 00 00 00 mov %esi,0x80(%eax) <== NOT EXECUTED switch ( api->schedpolicy ) { 10ca3b: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10ca3e: 85 f6 test %esi,%esi <== NOT EXECUTED 10ca40: 78 2c js 10ca6e <== NOT EXECUTED 10ca42: 83 7d 0c 02 cmpl $0x2,0xc(%ebp) <== NOT EXECUTED 10ca46: 7f 6c jg 10cab4 <== NOT EXECUTED case SCHED_OTHER: case SCHED_FIFO: case SCHED_RR: the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice; 10ca48: a1 64 51 12 00 mov 0x125164,%eax <== NOT EXECUTED 10ca4d: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 10ca50: 89 42 78 mov %eax,0x78(%edx) <== NOT EXECUTED /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of 10ca53: b8 ff 00 00 00 mov $0xff,%eax <== NOT EXECUTED 10ca58: 2b 83 80 00 00 00 sub 0x80(%ebx),%eax <== NOT EXECUTED the_thread->real_priority = 10ca5e: 89 42 18 mov %eax,0x18(%edx) <== NOT EXECUTED _POSIX_Priority_To_core( api->schedparam.sched_priority ); _Thread_Change_priority( 10ca61: 51 push %ecx <== NOT EXECUTED 10ca62: 6a 01 push $0x1 <== NOT EXECUTED 10ca64: 50 push %eax <== NOT EXECUTED 10ca65: 52 push %edx <== NOT EXECUTED 10ca66: e8 0d 24 00 00 call 10ee78 <_Thread_Change_priority> <== NOT EXECUTED 10ca6b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Watchdog_Remove( &api->Sporadic_timer ); _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); break; } _Thread_Enable_dispatch(); 10ca6e: e8 e1 28 00 00 call 10f354 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ca73: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return ESRCH; } 10ca75: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ca78: 5b pop %ebx <== NOT EXECUTED 10ca79: 5e pop %esi <== NOT EXECUTED 10ca7a: 5f pop %edi <== NOT EXECUTED 10ca7b: c9 leave <== NOT EXECUTED 10ca7c: c3 ret <== NOT EXECUTED 10ca7d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return EINVAL; budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; budget_callout = NULL; switch ( policy ) { 10ca80: c7 45 dc 02 00 00 00 movl $0x2,-0x24(%ebp) <== NOT EXECUTED 10ca87: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 10ca8e: e9 fb fe ff ff jmp 10c98e <== NOT EXECUTED 10ca93: 90 nop <== NOT EXECUTED 10ca94: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ca97: 85 c0 test %eax,%eax <== NOT EXECUTED 10ca99: 0f 85 d2 fe ff ff jne 10c971 <== NOT EXECUTED 10ca9f: c7 45 dc 01 00 00 00 movl $0x1,-0x24(%ebp) <== NOT EXECUTED 10caa6: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 10caad: e9 dc fe ff ff jmp 10c98e <== NOT EXECUTED 10cab2: 66 90 xchg %ax,%ax <== NOT EXECUTED api->schedpolicy = policy; api->schedparam = *param; the_thread->budget_algorithm = budget_algorithm; the_thread->budget_callout = budget_callout; switch ( api->schedpolicy ) { 10cab4: 83 7d 0c 03 cmpl $0x3,0xc(%ebp) <== NOT EXECUTED 10cab8: 75 b4 jne 10ca6e <== NOT EXECUTED TRUE ); break; case SCHED_SPORADIC: api->ss_high_priority = api->schedparam.sched_priority; 10caba: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax <== NOT EXECUTED 10cac0: 89 83 98 00 00 00 mov %eax,0x98(%ebx) <== NOT EXECUTED _Watchdog_Remove( &api->Sporadic_timer ); 10cac6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cac9: 8d 83 9c 00 00 00 lea 0x9c(%ebx),%eax <== NOT EXECUTED 10cacf: 50 push %eax <== NOT EXECUTED 10cad0: e8 27 3a 00 00 call 1104fc <_Watchdog_Remove> <== NOT EXECUTED _POSIX_Threads_Sporadic_budget_TSR( 0, the_thread ); 10cad5: 58 pop %eax <== NOT EXECUTED 10cad6: 5a pop %edx <== NOT EXECUTED 10cad7: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 10cada: 6a 00 push $0x0 <== NOT EXECUTED 10cadc: e8 bb fd ff ff call 10c89c <_POSIX_Threads_Sporadic_budget_TSR> <== NOT EXECUTED 10cae1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cae4: eb 88 jmp 10ca6e <== NOT EXECUTED 10cae6: 66 90 xchg %ax,%ax <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_POSIX ]; if ( api->schedpolicy == SCHED_SPORADIC ) (void) _Watchdog_Remove( &api->Sporadic_timer ); 10cae8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10caeb: 8d 83 9c 00 00 00 lea 0x9c(%ebx),%eax <== NOT EXECUTED 10caf1: 50 push %eax <== NOT EXECUTED 10caf2: e8 05 3a 00 00 call 1104fc <_Watchdog_Remove> <== NOT EXECUTED 10caf7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cafa: e9 14 ff ff ff jmp 10ca13 <== NOT EXECUTED 0010a2c8 : int pthread_setspecific( pthread_key_t key, const void *value ) { 10a2c8: 55 push %ebp <== NOT EXECUTED 10a2c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a2cb: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10a2ce: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10a2d1: 50 push %eax <== NOT EXECUTED 10a2d2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a2d5: 68 40 27 12 00 push $0x122740 <== NOT EXECUTED 10a2da: e8 91 27 00 00 call 10ca70 <_Objects_Get> <== NOT EXECUTED 10a2df: 89 c1 mov %eax,%ecx <== NOT EXECUTED uint32_t api; uint32_t index; Objects_Locations location; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 10a2e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a2e4: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED 10a2e7: 85 c0 test %eax,%eax <== NOT EXECUTED 10a2e9: 75 29 jne 10a314 <== NOT EXECUTED case OBJECTS_LOCAL: api = _Objects_Get_API( _Thread_Executing->Object.id ); 10a2eb: a1 5c 23 12 00 mov 0x12235c,%eax <== NOT EXECUTED 10a2f0: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED index = _Objects_Get_index( _Thread_Executing->Object.id ); the_key->Values[ api ][ index ] = (void *) value; 10a2f3: 89 d0 mov %edx,%eax <== NOT EXECUTED 10a2f5: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10a2f8: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10a2fb: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10a301: 8b 44 81 18 mov 0x18(%ecx,%eax,4),%eax <== NOT EXECUTED 10a305: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10a308: 89 0c 90 mov %ecx,(%eax,%edx,4) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a30b: e8 a4 2f 00 00 call 10d2b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a310: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a312: c9 leave <== NOT EXECUTED 10a313: c3 ret <== NOT EXECUTED uint32_t api; uint32_t index; Objects_Locations location; the_key = _POSIX_Keys_Get( key, &location ); switch ( location ) { 10a314: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a319: c9 leave <== NOT EXECUTED 10a31a: c3 ret <== NOT EXECUTED 00110444 : int pthread_sigmask( int how, const sigset_t *set, sigset_t *oset ) { 110444: 55 push %ebp <== NOT EXECUTED 110445: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110447: 57 push %edi <== NOT EXECUTED 110448: 56 push %esi <== NOT EXECUTED 110449: 53 push %ebx <== NOT EXECUTED 11044a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11044d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 110450: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 110453: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED POSIX_API_Control *api; if ( !set && !oset ) 110456: 85 f6 test %esi,%esi <== NOT EXECUTED 110458: 0f 84 8e 00 00 00 je 1104ec <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 11045e: 8b 3d 1c 24 12 00 mov 0x12241c,%edi <== NOT EXECUTED 110464: 8b 8f f8 00 00 00 mov 0xf8(%edi),%ecx <== NOT EXECUTED if ( oset ) 11046a: 85 d2 test %edx,%edx <== NOT EXECUTED 11046c: 74 08 je 110476 <== NOT EXECUTED *oset = api->signals_blocked; 11046e: 8b 81 c4 00 00 00 mov 0xc4(%ecx),%eax <== NOT EXECUTED 110474: 89 02 mov %eax,(%edx) <== NOT EXECUTED if ( !set ) return 0; switch ( how ) { 110476: 83 fb 01 cmp $0x1,%ebx <== NOT EXECUTED 110479: 74 65 je 1104e0 <== NOT EXECUTED 11047b: 83 fb 02 cmp $0x2,%ebx <== NOT EXECUTED 11047e: 74 3c je 1104bc <== NOT EXECUTED 110480: 85 db test %ebx,%ebx <== NOT EXECUTED 110482: 75 44 jne 1104c8 <== NOT EXECUTED break; case SIG_UNBLOCK: api->signals_blocked &= ~*set; break; case SIG_SETMASK: api->signals_blocked = *set; 110484: 8b 06 mov (%esi),%eax <== NOT EXECUTED 110486: 89 81 c4 00 00 00 mov %eax,0xc4(%ecx) <== NOT EXECUTED /* XXX are there critical section problems here? */ /* XXX evaluate the new set */ if ( ~api->signals_blocked & 11048c: 8b 15 80 2b 12 00 mov 0x122b80,%edx <== NOT EXECUTED 110492: 0b 91 c8 00 00 00 or 0xc8(%ecx),%edx <== NOT EXECUTED 110498: 8b 81 c4 00 00 00 mov 0xc4(%ecx),%eax <== NOT EXECUTED 11049e: f7 d0 not %eax <== NOT EXECUTED 1104a0: 85 c2 test %eax,%edx <== NOT EXECUTED 1104a2: 75 0c jne 1104b0 <== NOT EXECUTED (api->signals_pending | _POSIX_signals_Pending) ) { _Thread_Executing->do_post_task_switch_extension = true; _Thread_Dispatch(); 1104a4: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 1104a6: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1104a9: 5b pop %ebx <== NOT EXECUTED 1104aa: 5e pop %esi <== NOT EXECUTED 1104ab: 5f pop %edi <== NOT EXECUTED 1104ac: c9 leave <== NOT EXECUTED 1104ad: c3 ret <== NOT EXECUTED 1104ae: 66 90 xchg %ax,%ax <== NOT EXECUTED /* XXX evaluate the new set */ if ( ~api->signals_blocked & (api->signals_pending | _POSIX_signals_Pending) ) { _Thread_Executing->do_post_task_switch_extension = true; 1104b0: c6 47 75 01 movb $0x1,0x75(%edi) <== NOT EXECUTED _Thread_Dispatch(); 1104b4: e8 87 cd ff ff call 10d240 <_Thread_Dispatch> <== NOT EXECUTED 1104b9: eb e9 jmp 1104a4 <== NOT EXECUTED 1104bb: 90 nop <== NOT EXECUTED switch ( how ) { case SIG_BLOCK: api->signals_blocked |= *set; break; case SIG_UNBLOCK: api->signals_blocked &= ~*set; 1104bc: 8b 06 mov (%esi),%eax <== NOT EXECUTED 1104be: f7 d0 not %eax <== NOT EXECUTED 1104c0: 21 81 c4 00 00 00 and %eax,0xc4(%ecx) <== NOT EXECUTED 1104c6: eb c4 jmp 11048c <== NOT EXECUTED break; case SIG_SETMASK: api->signals_blocked = *set; break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 1104c8: e8 ff 17 00 00 call 111ccc <__errno> <== NOT EXECUTED 1104cd: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1104d3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED _Thread_Executing->do_post_task_switch_extension = true; _Thread_Dispatch(); } return 0; } 1104d8: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1104db: 5b pop %ebx <== NOT EXECUTED 1104dc: 5e pop %esi <== NOT EXECUTED 1104dd: 5f pop %edi <== NOT EXECUTED 1104de: c9 leave <== NOT EXECUTED 1104df: c3 ret <== NOT EXECUTED if ( !set ) return 0; switch ( how ) { case SIG_BLOCK: api->signals_blocked |= *set; 1104e0: 8b 06 mov (%esi),%eax <== NOT EXECUTED 1104e2: 09 81 c4 00 00 00 or %eax,0xc4(%ecx) <== NOT EXECUTED 1104e8: eb a2 jmp 11048c <== NOT EXECUTED 1104ea: 66 90 xchg %ax,%ax <== NOT EXECUTED sigset_t *oset ) { POSIX_API_Control *api; if ( !set && !oset ) 1104ec: 85 d2 test %edx,%edx <== NOT EXECUTED 1104ee: 74 d8 je 1104c8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; if ( oset ) *oset = api->signals_blocked; 1104f0: a1 1c 24 12 00 mov 0x12241c,%eax <== NOT EXECUTED 1104f5: 8b 80 f8 00 00 00 mov 0xf8(%eax),%eax <== NOT EXECUTED 1104fb: 8b 80 c4 00 00 00 mov 0xc4(%eax),%eax <== NOT EXECUTED 110501: 89 02 mov %eax,(%edx) <== NOT EXECUTED 110503: 31 c0 xor %eax,%eax <== NOT EXECUTED _Thread_Executing->do_post_task_switch_extension = true; _Thread_Dispatch(); } return 0; } 110505: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 110508: 5b pop %ebx <== NOT EXECUTED 110509: 5e pop %esi <== NOT EXECUTED 11050a: 5f pop %edi <== NOT EXECUTED 11050b: c9 leave <== NOT EXECUTED 11050c: c3 ret <== NOT EXECUTED 0010a1ec : */ int pthread_spin_destroy( pthread_spinlock_t *spinlock ) { 10a1ec: 55 push %ebp <== NOT EXECUTED 10a1ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a1ef: 53 push %ebx <== NOT EXECUTED 10a1f0: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10a1f3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; if ( !spinlock ) 10a1f6: 85 d2 test %edx,%edx <== NOT EXECUTED 10a1f8: 74 36 je 10a230 <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 10a1fa: 53 push %ebx <== NOT EXECUTED 10a1fb: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a1fe: 50 push %eax <== NOT EXECUTED 10a1ff: ff 32 pushl (%edx) <== NOT EXECUTED 10a201: 68 c0 0b 12 00 push $0x120bc0 <== NOT EXECUTED 10a206: e8 61 23 00 00 call 10c56c <_Objects_Get> <== NOT EXECUTED 10a20b: 89 c3 mov %eax,%ebx <== NOT EXECUTED return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 10a20d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a210: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 10a213: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a215: 75 19 jne 10a230 <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10a217: 8b 40 18 mov 0x18(%eax),%eax <== NOT EXECUTED case OBJECTS_LOCAL: if ( _CORE_spinlock_Is_busy( &the_spinlock->Spinlock ) ) { 10a21a: 85 c0 test %eax,%eax <== NOT EXECUTED 10a21c: 74 1e je 10a23c <== NOT EXECUTED _Thread_Enable_dispatch(); 10a21e: e8 8d 2b 00 00 call 10cdb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a223: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a228: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a22b: c9 leave <== NOT EXECUTED 10a22c: c3 ret <== NOT EXECUTED 10a22d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Objects_Close( &_POSIX_Spinlock_Information, &the_spinlock->Object ); _POSIX_Spinlock_Free( the_spinlock ); _Thread_Enable_dispatch(); return 0; 10a230: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a235: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a238: c9 leave <== NOT EXECUTED 10a239: c3 ret <== NOT EXECUTED 10a23a: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( _CORE_spinlock_Is_busy( &the_spinlock->Spinlock ) ) { _Thread_Enable_dispatch(); return EBUSY; } _Objects_Close( &_POSIX_Spinlock_Information, &the_spinlock->Object ); 10a23c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a23f: 53 push %ebx <== NOT EXECUTED 10a240: 68 c0 0b 12 00 push $0x120bc0 <== NOT EXECUTED 10a245: e8 ae 1e 00 00 call 10c0f8 <_Objects_Close> <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * 10a24a: 58 pop %eax <== NOT EXECUTED 10a24b: 5a pop %edx <== NOT EXECUTED 10a24c: 53 push %ebx <== NOT EXECUTED 10a24d: 68 c0 0b 12 00 push $0x120bc0 <== NOT EXECUTED 10a252: e8 e1 21 00 00 call 10c438 <_Objects_Free> <== NOT EXECUTED _POSIX_Spinlock_Free( the_spinlock ); _Thread_Enable_dispatch(); 10a257: e8 54 2b 00 00 call 10cdb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a25c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a25e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a261: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a264: c9 leave <== NOT EXECUTED 10a265: c3 ret <== NOT EXECUTED 0010a268 : int pthread_spin_init( pthread_spinlock_t *spinlock, int pshared ) { 10a268: 55 push %ebp <== NOT EXECUTED 10a269: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a26b: 56 push %esi <== NOT EXECUTED 10a26c: 53 push %ebx <== NOT EXECUTED 10a26d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10a270: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED POSIX_Spinlock_Control *the_spinlock; CORE_spinlock_Attributes attributes; if ( !spinlock ) 10a273: 85 f6 test %esi,%esi <== NOT EXECUTED 10a275: 74 61 je 10a2d8 <== NOT EXECUTED return EINVAL; switch ( pshared ) { 10a277: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a27a: 85 c0 test %eax,%eax <== NOT EXECUTED 10a27c: 75 5a jne 10a2d8 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a27e: a1 b8 08 12 00 mov 0x1208b8,%eax <== NOT EXECUTED 10a283: 40 inc %eax <== NOT EXECUTED 10a284: a3 b8 08 12 00 mov %eax,0x1208b8 <== NOT EXECUTED */ /**@{*/ #ifdef __cplusplus extern "C" { #endif 10a289: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a28c: 68 c0 0b 12 00 push $0x120bc0 <== NOT EXECUTED 10a291: e8 e2 1d 00 00 call 10c078 <_Objects_Allocate> <== NOT EXECUTED 10a296: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_spinlock = _POSIX_Spinlock_Allocate(); if ( !the_spinlock ) { 10a298: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a29b: 85 c0 test %eax,%eax <== NOT EXECUTED 10a29d: 74 45 je 10a2e4 <== NOT EXECUTED _Thread_Enable_dispatch(); return EAGAIN; } _CORE_spinlock_Initialize( &the_spinlock->Spinlock, &attributes ); 10a29f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a2a2: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10a2a5: 50 push %eax <== NOT EXECUTED 10a2a6: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10a2a9: 50 push %eax <== NOT EXECUTED 10a2aa: e8 11 19 00 00 call 10bbc0 <_CORE_spinlock_Initialize> <== NOT EXECUTED 10a2af: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10a2b2: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10a2b5: a1 dc 0b 12 00 mov 0x120bdc,%eax <== NOT EXECUTED 10a2ba: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10a2bd: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED _Objects_Open_u32( &_POSIX_Spinlock_Information, &the_spinlock->Object, 0 ); *spinlock = the_spinlock->Object.id; 10a2c4: 89 0e mov %ecx,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a2c6: e8 e5 2a 00 00 call 10cdb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a2cb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a2cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10a2d0: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a2d3: 5b pop %ebx <== NOT EXECUTED 10a2d4: 5e pop %esi <== NOT EXECUTED 10a2d5: c9 leave <== NOT EXECUTED 10a2d6: c3 ret <== NOT EXECUTED 10a2d7: 90 nop <== NOT EXECUTED _Objects_Open_u32( &_POSIX_Spinlock_Information, &the_spinlock->Object, 0 ); *spinlock = the_spinlock->Object.id; _Thread_Enable_dispatch(); return 0; 10a2d8: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 10a2dd: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a2e0: 5b pop %ebx <== NOT EXECUTED 10a2e1: 5e pop %esi <== NOT EXECUTED 10a2e2: c9 leave <== NOT EXECUTED 10a2e3: c3 ret <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_spinlock = _POSIX_Spinlock_Allocate(); if ( !the_spinlock ) { _Thread_Enable_dispatch(); 10a2e4: e8 c7 2a 00 00 call 10cdb0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a2e9: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 10a2ee: eb ed jmp 10a2dd <== NOT EXECUTED 0010a2f0 : */ int pthread_spin_lock( pthread_spinlock_t *spinlock ) { 10a2f0: 55 push %ebp <== NOT EXECUTED 10a2f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a2f3: 53 push %ebx <== NOT EXECUTED 10a2f4: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10a2f7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 10a2fa: 85 d2 test %edx,%edx <== NOT EXECUTED 10a2fc: 74 1b je 10a319 <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 10a2fe: 53 push %ebx <== NOT EXECUTED 10a2ff: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a302: 50 push %eax <== NOT EXECUTED 10a303: ff 32 pushl (%edx) <== NOT EXECUTED 10a305: 68 c0 0b 12 00 push $0x120bc0 <== NOT EXECUTED 10a30a: e8 5d 22 00 00 call 10c56c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 10a30f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a312: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 10a315: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a317: 74 0b je 10a324 <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, TRUE, 0 ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 10a319: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a31e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a321: c9 leave <== NOT EXECUTED 10a322: c3 ret <== NOT EXECUTED 10a323: 90 nop <== NOT EXECUTED the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, TRUE, 0 ); 10a324: 52 push %edx <== NOT EXECUTED 10a325: 6a 00 push $0x0 <== NOT EXECUTED 10a327: 6a 01 push $0x1 <== NOT EXECUTED 10a329: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10a32c: 50 push %eax <== NOT EXECUTED 10a32d: e8 fe 18 00 00 call 10bc30 <_CORE_spinlock_Wait> <== NOT EXECUTED 10a332: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Enable_dispatch(); 10a334: e8 77 2a 00 00 call 10cdb0 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 10a339: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a33c: e8 0b 00 00 00 call 10a34c <_POSIX_Spinlock_Translate_core_spinlock_return_code> <== NOT EXECUTED 10a341: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a344: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a347: c9 leave <== NOT EXECUTED 10a348: c3 ret <== NOT EXECUTED 0010a35c : */ int pthread_spin_trylock( pthread_spinlock_t *spinlock ) { 10a35c: 55 push %ebp <== NOT EXECUTED 10a35d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a35f: 53 push %ebx <== NOT EXECUTED 10a360: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10a363: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 10a366: 85 d2 test %edx,%edx <== NOT EXECUTED 10a368: 74 1b je 10a385 <== NOT EXECUTED 10a36a: 53 push %ebx <== NOT EXECUTED 10a36b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a36e: 50 push %eax <== NOT EXECUTED 10a36f: ff 32 pushl (%edx) <== NOT EXECUTED 10a371: 68 c0 0b 12 00 push $0x120bc0 <== NOT EXECUTED 10a376: e8 f1 21 00 00 call 10c56c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 10a37b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a37e: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 10a381: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a383: 74 0b je 10a390 <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, FALSE, 0 ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 10a385: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a38a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a38d: c9 leave <== NOT EXECUTED 10a38e: c3 ret <== NOT EXECUTED 10a38f: 90 nop <== NOT EXECUTED the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { case OBJECTS_LOCAL: status = _CORE_spinlock_Wait( &the_spinlock->Spinlock, FALSE, 0 ); 10a390: 52 push %edx <== NOT EXECUTED 10a391: 6a 00 push $0x0 <== NOT EXECUTED 10a393: 6a 00 push $0x0 <== NOT EXECUTED 10a395: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10a398: 50 push %eax <== NOT EXECUTED 10a399: e8 92 18 00 00 call 10bc30 <_CORE_spinlock_Wait> <== NOT EXECUTED 10a39e: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Enable_dispatch(); 10a3a0: e8 0b 2a 00 00 call 10cdb0 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 10a3a5: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a3a8: e8 9f ff ff ff call 10a34c <_POSIX_Spinlock_Translate_core_spinlock_return_code> <== NOT EXECUTED 10a3ad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a3b0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a3b3: c9 leave <== NOT EXECUTED 10a3b4: c3 ret <== NOT EXECUTED 0010a3b8 : */ int pthread_spin_unlock( pthread_spinlock_t *spinlock ) { 10a3b8: 55 push %ebp <== NOT EXECUTED 10a3b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a3bb: 53 push %ebx <== NOT EXECUTED 10a3bc: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10a3bf: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED POSIX_Spinlock_Control *the_spinlock = NULL; Objects_Locations location; CORE_spinlock_Status status; if ( !spinlock ) 10a3c2: 85 d2 test %edx,%edx <== NOT EXECUTED 10a3c4: 74 1b je 10a3e1 <== NOT EXECUTED 10a3c6: 51 push %ecx <== NOT EXECUTED 10a3c7: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a3ca: 50 push %eax <== NOT EXECUTED 10a3cb: ff 32 pushl (%edx) <== NOT EXECUTED 10a3cd: 68 c0 0b 12 00 push $0x120bc0 <== NOT EXECUTED 10a3d2: e8 95 21 00 00 call 10c56c <_Objects_Get> <== NOT EXECUTED return EINVAL; the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { 10a3d7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a3da: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10a3dd: 85 d2 test %edx,%edx <== NOT EXECUTED 10a3df: 74 0b je 10a3ec <== NOT EXECUTED case OBJECTS_LOCAL: status = _CORE_spinlock_Release( &the_spinlock->Spinlock ); _Thread_Enable_dispatch(); return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 10a3e1: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a3e6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a3e9: c9 leave <== NOT EXECUTED 10a3ea: c3 ret <== NOT EXECUTED 10a3eb: 90 nop <== NOT EXECUTED the_spinlock = _POSIX_Spinlock_Get( spinlock, &location ); switch ( location ) { case OBJECTS_LOCAL: status = _CORE_spinlock_Release( &the_spinlock->Spinlock ); 10a3ec: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a3ef: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10a3f2: 50 push %eax <== NOT EXECUTED 10a3f3: e8 ec 17 00 00 call 10bbe4 <_CORE_spinlock_Release> <== NOT EXECUTED 10a3f8: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Enable_dispatch(); 10a3fa: e8 b1 29 00 00 call 10cdb0 <_Thread_Enable_dispatch> <== NOT EXECUTED return _POSIX_Spinlock_Translate_core_spinlock_return_code( status ); 10a3ff: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a402: e8 45 ff ff ff call 10a34c <_POSIX_Spinlock_Translate_core_spinlock_return_code> <== NOT EXECUTED 10a407: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return EINVAL; } 10a40a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a40d: c9 leave <== NOT EXECUTED 10a40e: c3 ret <== NOT EXECUTED 0010a4d8 : * * 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183 */ void pthread_testcancel( void ) { 10a4d8: 55 push %ebp <== NOT EXECUTED 10a4d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4db: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED * 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() ) 10a4de: a1 b8 22 12 00 mov 0x1222b8,%eax <== NOT EXECUTED 10a4e3: 85 c0 test %eax,%eax <== NOT EXECUTED 10a4e5: 75 42 jne 10a529 <== NOT EXECUTED return; thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; 10a4e7: a1 dc 22 12 00 mov 0x1222dc,%eax <== NOT EXECUTED 10a4ec: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED 10a4f2: a1 18 22 12 00 mov 0x122218,%eax <== NOT EXECUTED 10a4f7: 40 inc %eax <== NOT EXECUTED 10a4f8: a3 18 22 12 00 mov %eax,0x122218 <== NOT EXECUTED _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && 10a4fd: 8b 8a cc 00 00 00 mov 0xcc(%edx),%ecx <== NOT EXECUTED 10a503: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a505: 75 25 jne 10a52c <== NOT EXECUTED 10a507: 8b 82 d4 00 00 00 mov 0xd4(%edx),%eax <== NOT EXECUTED 10a50d: 85 c0 test %eax,%eax <== NOT EXECUTED 10a50f: 74 1b je 10a52c <== NOT EXECUTED thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a511: e8 56 28 00 00 call 10cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED if ( cancel ) _POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED ); 10a516: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a519: 6a ff push $0xffffffff <== NOT EXECUTED 10a51b: ff 35 dc 22 12 00 pushl 0x1222dc <== NOT EXECUTED 10a521: e8 42 fa ff ff call 109f68 <_POSIX_Thread_Exit> <== NOT EXECUTED 10a526: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10a529: c9 leave <== NOT EXECUTED 10a52a: c3 ret <== NOT EXECUTED 10a52b: 90 nop <== NOT EXECUTED 10a52c: c9 leave <== NOT EXECUTED _Thread_Disable_dispatch(); if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE && thread_support->cancelation_requested ) cancel = true; _Thread_Enable_dispatch(); 10a52d: e9 3a 28 00 00 jmp 10cd6c <_Thread_Enable_dispatch> <== NOT EXECUTED 001171f4 : ssize_t read( int fd, void *buffer, size_t count ) { 1171f4: 55 push %ebp <== NOT EXECUTED 1171f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1171f7: 56 push %esi <== NOT EXECUTED 1171f8: 53 push %ebx <== NOT EXECUTED 1171f9: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1171fc: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1171ff: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 117202: 3b 15 00 b1 11 00 cmp 0x11b100,%edx <== NOT EXECUTED 117208: 73 56 jae 117260 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 11720a: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 11720d: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 117210: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 117217: 03 1d 30 f6 11 00 add 0x11f630,%ebx <== NOT EXECUTED rtems_libio_check_is_open( iop ); 11721d: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 117220: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 117223: 74 3b je 117260 <== NOT EXECUTED rtems_libio_check_buffer( buffer ); 117225: 85 f6 test %esi,%esi <== NOT EXECUTED 117227: 74 4b je 117274 <== NOT EXECUTED rtems_libio_check_count( count ); 117229: 85 c9 test %ecx,%ecx <== NOT EXECUTED 11722b: 74 27 je 117254 <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 11722d: a8 02 test $0x2,%al <== NOT EXECUTED 11722f: 74 43 je 117274 <== NOT EXECUTED /* * Now process the read(). */ if ( !iop->handlers->read_h ) 117231: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 117234: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 117237: 85 c0 test %eax,%eax <== NOT EXECUTED 117239: 74 4b je 117286 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); rc = (*iop->handlers->read_h)( iop, buffer, count ); 11723b: 52 push %edx <== NOT EXECUTED 11723c: 51 push %ecx <== NOT EXECUTED 11723d: 56 push %esi <== NOT EXECUTED 11723e: 53 push %ebx <== NOT EXECUTED 11723f: ff d0 call *%eax <== NOT EXECUTED if ( rc > 0 ) 117241: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 117244: 85 c0 test %eax,%eax <== NOT EXECUTED 117246: 7e 03 jle 11724b <== NOT EXECUTED iop->offset += rc; 117248: 01 43 08 add %eax,0x8(%ebx) <== NOT EXECUTED return rc; } 11724b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11724e: 5b pop %ebx <== NOT EXECUTED 11724f: 5e pop %esi <== NOT EXECUTED 117250: c9 leave <== NOT EXECUTED 117251: c3 ret <== NOT EXECUTED 117252: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); 117254: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( rc > 0 ) iop->offset += rc; return rc; } 117256: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 117259: 5b pop %ebx <== NOT EXECUTED 11725a: 5e pop %esi <== NOT EXECUTED 11725b: c9 leave <== NOT EXECUTED 11725c: c3 ret <== NOT EXECUTED 11725d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); 117260: e8 1b 9a ff ff call 110c80 <__errno> <== NOT EXECUTED 117265: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 11726b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 117270: eb d9 jmp 11724b <== NOT EXECUTED 117272: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 117274: e8 07 9a ff ff call 110c80 <__errno> <== NOT EXECUTED 117279: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11727f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 117284: eb c5 jmp 11724b <== NOT EXECUTED /* * Now process the read(). */ if ( !iop->handlers->read_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 117286: e8 f5 99 ff ff call 110c80 <__errno> <== NOT EXECUTED 11728b: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 117291: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 117296: eb b3 jmp 11724b <== NOT EXECUTED 001250bc : /* * get next entry in a directory. */ struct dirent * readdir( DIR *dirp ) { 1250bc: 55 push %ebp <== NOT EXECUTED 1250bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1250bf: 56 push %esi <== NOT EXECUTED 1250c0: 53 push %ebx <== NOT EXECUTED 1250c1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED register struct dirent *dp; if ( !dirp ) 1250c4: 85 db test %ebx,%ebx <== NOT EXECUTED 1250c6: 75 0b jne 1250d3 <== NOT EXECUTED 1250c8: eb 67 jmp 125131 <== NOT EXECUTED 1250ca: 66 90 xchg %ax,%ax <== NOT EXECUTED if (dirp->dd_size <= 0) return NULL; } if (dirp->dd_loc >= dirp->dd_size) { dirp->dd_loc = 0; 1250cc: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED if ( !dirp ) return NULL; for (;;) { if (dirp->dd_loc == 0) { 1250d3: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 1250d6: 85 d2 test %edx,%edx <== NOT EXECUTED 1250d8: 74 3a je 125114 <== NOT EXECUTED dirp->dd_len); if (dirp->dd_size <= 0) return NULL; } if (dirp->dd_loc >= dirp->dd_size) { 1250da: 39 53 08 cmp %edx,0x8(%ebx) <== NOT EXECUTED 1250dd: 7e ed jle 1250cc <== NOT EXECUTED dirp->dd_loc = 0; continue; } dp = (struct dirent *)(dirp->dd_buf + dirp->dd_loc); 1250df: 89 d1 mov %edx,%ecx <== NOT EXECUTED 1250e1: 03 4b 0c add 0xc(%ebx),%ecx <== NOT EXECUTED if ((intptr_t)dp & 03) /* bogus pointer check */ 1250e4: f6 c1 03 test $0x3,%cl <== NOT EXECUTED 1250e7: 75 48 jne 125131 <== NOT EXECUTED return NULL; if (dp->d_reclen <= 0 || 1250e9: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 1250ec: 66 85 c0 test %ax,%ax <== NOT EXECUTED 1250ef: 74 40 je 125131 <== NOT EXECUTED 1250f1: 0f b7 f0 movzwl %ax,%esi <== NOT EXECUTED 1250f4: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 1250f7: 40 inc %eax <== NOT EXECUTED 1250f8: 29 d0 sub %edx,%eax <== NOT EXECUTED 1250fa: 39 c6 cmp %eax,%esi <== NOT EXECUTED 1250fc: 7f 33 jg 125131 <== NOT EXECUTED dp->d_reclen > dirp->dd_len + 1 - dirp->dd_loc) return NULL; dirp->dd_loc += dp->d_reclen; 1250fe: 8d 04 32 lea (%edx,%esi,1),%eax <== NOT EXECUTED 125101: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED if (dp->d_ino == 0) 125104: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 125106: 85 c0 test %eax,%eax <== NOT EXECUTED 125108: 74 c9 je 1250d3 <== NOT EXECUTED continue; return (dp); } } 12510a: 89 c8 mov %ecx,%eax <== NOT EXECUTED 12510c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12510f: 5b pop %ebx <== NOT EXECUTED 125110: 5e pop %esi <== NOT EXECUTED 125111: c9 leave <== NOT EXECUTED 125112: c3 ret <== NOT EXECUTED 125113: 90 nop <== NOT EXECUTED if ( !dirp ) return NULL; for (;;) { if (dirp->dd_loc == 0) { dirp->dd_size = getdents (dirp->dd_fd, 125114: 52 push %edx <== NOT EXECUTED 125115: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 125118: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 12511b: ff 33 pushl (%ebx) <== NOT EXECUTED 12511d: e8 1e aa 00 00 call 12fb40 <== NOT EXECUTED 125122: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED dirp->dd_buf, dirp->dd_len); if (dirp->dd_size <= 0) 125125: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125128: 85 c0 test %eax,%eax <== NOT EXECUTED 12512a: 7e 05 jle 125131 <== NOT EXECUTED 12512c: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 12512f: eb a9 jmp 1250da <== NOT EXECUTED return NULL; if (dp->d_reclen <= 0 || dp->d_reclen > dirp->dd_len + 1 - dirp->dd_loc) return NULL; dirp->dd_loc += dp->d_reclen; if (dp->d_ino == 0) 125131: 31 c9 xor %ecx,%ecx <== NOT EXECUTED continue; return (dp); } } 125133: 89 c8 mov %ecx,%eax <== NOT EXECUTED 125135: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 125138: 5b pop %ebx <== NOT EXECUTED 125139: 5e pop %esi <== NOT EXECUTED 12513a: c9 leave <== NOT EXECUTED 12513b: c3 ret <== NOT EXECUTED 0012513c : ssize_t readlink( const char *pathname, char *buf, size_t bufsize ) { 12513c: 55 push %ebp <== NOT EXECUTED 12513d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12513f: 56 push %esi <== NOT EXECUTED 125140: 53 push %ebx <== NOT EXECUTED 125141: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 125144: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED rtems_filesystem_location_info_t loc; int result; if (!buf) 125147: 85 db test %ebx,%ebx <== NOT EXECUTED 125149: 0f 84 99 00 00 00 je 1251e8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); result = rtems_filesystem_evaluate_path( pathname, 0, &loc, false ); 12514f: 6a 00 push $0x0 <== NOT EXECUTED 125151: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 125154: 56 push %esi <== NOT EXECUTED 125155: 6a 00 push $0x0 <== NOT EXECUTED 125157: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12515a: e8 cd 60 fe ff call 10b22c <== NOT EXECUTED if ( result != 0 ) 12515f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125162: 85 c0 test %eax,%eax <== NOT EXECUTED 125164: 75 72 jne 1251d8 <== NOT EXECUTED return -1; if ( !loc.ops->node_type_h ){ 125166: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 125169: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 12516c: 85 c0 test %eax,%eax <== NOT EXECUTED 12516e: 74 4d je 1251bd <== 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 ){ 125170: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125173: 56 push %esi <== NOT EXECUTED 125174: ff d0 call *%eax <== NOT EXECUTED 125176: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125179: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 12517c: 0f 85 82 00 00 00 jne 125204 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !loc.ops->readlink_h ){ 125182: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 125185: 8b 50 3c mov 0x3c(%eax),%edx <== NOT EXECUTED 125188: 85 d2 test %edx,%edx <== NOT EXECUTED 12518a: 0f 84 9d 00 00 00 je 12522d <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); 125190: 50 push %eax <== NOT EXECUTED 125191: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 125194: 53 push %ebx <== NOT EXECUTED 125195: 56 push %esi <== NOT EXECUTED 125196: ff d2 call *%edx <== NOT EXECUTED 125198: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 12519a: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 12519d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1251a0: 85 c0 test %eax,%eax <== NOT EXECUTED 1251a2: 74 10 je 1251b4 <== NOT EXECUTED 1251a4: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1251a7: 85 c0 test %eax,%eax <== NOT EXECUTED 1251a9: 74 09 je 1251b4 <== NOT EXECUTED 1251ab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1251ae: 56 push %esi <== NOT EXECUTED 1251af: ff d0 call *%eax <== NOT EXECUTED 1251b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 1251b4: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1251b6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1251b9: 5b pop %ebx <== NOT EXECUTED 1251ba: 5e pop %esi <== NOT EXECUTED 1251bb: c9 leave <== NOT EXECUTED 1251bc: c3 ret <== NOT EXECUTED result = rtems_filesystem_evaluate_path( pathname, 0, &loc, false ); if ( result != 0 ) return -1; if ( !loc.ops->node_type_h ){ rtems_filesystem_freenode( &loc ); 1251bd: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 1251c0: 85 c0 test %eax,%eax <== NOT EXECUTED 1251c2: 74 09 je 1251cd <== NOT EXECUTED 1251c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1251c7: 56 push %esi <== NOT EXECUTED 1251c8: ff d0 call *%eax <== NOT EXECUTED 1251ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1251cd: e8 82 c6 00 00 call 131854 <__errno> <== NOT EXECUTED 1251d2: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1251d8: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); rtems_filesystem_freenode( &loc ); return result; } 1251dd: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1251df: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1251e2: 5b pop %ebx <== NOT EXECUTED 1251e3: 5e pop %esi <== NOT EXECUTED 1251e4: c9 leave <== NOT EXECUTED 1251e5: c3 ret <== NOT EXECUTED 1251e6: 66 90 xchg %ax,%ax <== NOT EXECUTED { rtems_filesystem_location_info_t loc; int result; if (!buf) rtems_set_errno_and_return_minus_one( EFAULT ); 1251e8: e8 67 c6 00 00 call 131854 <__errno> <== NOT EXECUTED 1251ed: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 1251f3: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); rtems_filesystem_freenode( &loc ); return result; } 1251f8: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1251fa: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1251fd: 5b pop %ebx <== NOT EXECUTED 1251fe: 5e pop %esi <== NOT EXECUTED 1251ff: c9 leave <== NOT EXECUTED 125200: c3 ret <== NOT EXECUTED 125201: 8d 76 00 lea 0x0(%esi),%esi <== 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 ); 125204: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 125207: 85 c0 test %eax,%eax <== NOT EXECUTED 125209: 74 10 je 12521b <== NOT EXECUTED 12520b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12520e: 85 c0 test %eax,%eax <== NOT EXECUTED 125210: 74 09 je 12521b <== NOT EXECUTED 125212: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125215: 56 push %esi <== NOT EXECUTED 125216: ff d0 call *%eax <== NOT EXECUTED 125218: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 12521b: e8 34 c6 00 00 call 131854 <__errno> <== NOT EXECUTED 125220: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 125226: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 12522b: eb 87 jmp 1251b4 <== NOT EXECUTED } if ( !loc.ops->readlink_h ){ rtems_filesystem_freenode( &loc ); 12522d: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 125230: 85 c0 test %eax,%eax <== NOT EXECUTED 125232: 74 09 je 12523d <== NOT EXECUTED 125234: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125237: 56 push %esi <== NOT EXECUTED 125238: ff d0 call *%eax <== NOT EXECUTED 12523a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 12523d: e8 12 c6 00 00 call 131854 <__errno> <== NOT EXECUTED 125242: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 125248: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 12524d: e9 62 ff ff ff jmp 1251b4 <== NOT EXECUTED 00117318 : { size_t old_size; char *new_area; size_t resize; MSBUMP(realloc_calls, 1); 117318: 55 push %ebp <== NOT EXECUTED 117319: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11731b: 57 push %edi <== NOT EXECUTED 11731c: 56 push %esi <== NOT EXECUTED 11731d: 53 push %ebx <== NOT EXECUTED 11731e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 117321: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 117324: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 117327: ff 05 d0 f6 11 00 incl 0x11f6d0 <== NOT EXECUTED /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 11732d: 83 3d 84 f9 11 00 03 cmpl $0x3,0x11f984 <== NOT EXECUTED 117334: 74 6e je 1173a4 <== NOT EXECUTED } /* * Continue with realloc(). */ if ( !ptr ) 117336: 85 db test %ebx,%ebx <== NOT EXECUTED 117338: 74 3a je 117374 <== NOT EXECUTED return malloc( size ); if ( !size ) { 11733a: 85 f6 test %esi,%esi <== NOT EXECUTED 11733c: 74 46 je 117384 <== NOT EXECUTED free( ptr ); return (void *) 0; } if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) { 11733e: 52 push %edx <== NOT EXECUTED 11733f: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 117342: 50 push %eax <== NOT EXECUTED 117343: 53 push %ebx <== NOT EXECUTED 117344: 68 60 f6 11 00 push $0x11f660 <== NOT EXECUTED 117349: e8 5a 01 00 00 call 1174a8 <_Protected_heap_Get_block_size> <== NOT EXECUTED 11734e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 117351: 84 c0 test %al,%al <== NOT EXECUTED 117353: 74 3f je 117394 <== NOT EXECUTED #if defined(RTEMS_MALLOC_BOUNDARY_HELPERS) if (rtems_malloc_boundary_helpers) resize += (*rtems_malloc_boundary_helpers->overhead)(); #endif if ( _Protected_heap_Resize_block( &RTEMS_Malloc_Heap, ptr, resize ) ) { 117355: 50 push %eax <== NOT EXECUTED 117356: 56 push %esi <== NOT EXECUTED 117357: 53 push %ebx <== NOT EXECUTED 117358: 68 60 f6 11 00 push $0x11f660 <== NOT EXECUTED 11735d: e8 7e 01 00 00 call 1174e0 <_Protected_heap_Resize_block> <== NOT EXECUTED 117362: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 117365: 84 c0 test %al,%al <== NOT EXECUTED 117367: 74 5b je 1173c4 <== NOT EXECUTED memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; } 117369: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11736b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11736e: 5b pop %ebx <== NOT EXECUTED 11736f: 5e pop %esi <== NOT EXECUTED 117370: 5f pop %edi <== NOT EXECUTED 117371: c9 leave <== NOT EXECUTED 117372: c3 ret <== NOT EXECUTED 117373: 90 nop <== NOT EXECUTED /* * Continue with realloc(). */ if ( !ptr ) return malloc( size ); 117374: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 117377: 56 push %esi <== NOT EXECUTED 117378: e8 3b ff fe ff call 1072b8 <== NOT EXECUTED 11737d: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11737f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 117382: eb e5 jmp 117369 <== NOT EXECUTED if ( !size ) { free( ptr ); 117384: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 117387: 53 push %ebx <== NOT EXECUTED 117388: e8 13 fd fe ff call 1070a0 <== NOT EXECUTED 11738d: 31 db xor %ebx,%ebx <== NOT EXECUTED 11738f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 117392: eb d5 jmp 117369 <== NOT EXECUTED return (void *) 0; } if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) { errno = EINVAL; 117394: e8 e7 98 ff ff call 110c80 <__errno> <== NOT EXECUTED 117399: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11739f: 31 db xor %ebx,%ebx <== NOT EXECUTED 1173a1: eb c6 jmp 117369 <== NOT EXECUTED 1173a3: 90 nop <== 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) 1173a4: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 1173a9: 85 c0 test %eax,%eax <== NOT EXECUTED 1173ab: 74 04 je 1173b1 <== NOT EXECUTED } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; 1173ad: 31 db xor %ebx,%ebx <== NOT EXECUTED 1173af: eb b8 jmp 117369 <== NOT EXECUTED if (_System_state_Is_up(_System_state_Get())) { if (_Thread_Dispatch_disable_level > 0) return (void *) 0; if (_ISR_Nest_level > 0) 1173b1: a1 58 f8 11 00 mov 0x11f858,%eax <== NOT EXECUTED 1173b6: 85 c0 test %eax,%eax <== NOT EXECUTED 1173b8: 0f 84 78 ff ff ff je 117336 <== NOT EXECUTED } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; 1173be: 31 db xor %ebx,%ebx <== NOT EXECUTED 1173c0: eb a7 jmp 117369 <== NOT EXECUTED 1173c2: 66 90 xchg %ax,%ax <== NOT EXECUTED * There used to be a free on this error case but it is wrong to * free the memory per OpenGroup Single UNIX Specification V2 * and the C Standard. */ new_area = malloc( size ); 1173c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1173c7: 56 push %esi <== NOT EXECUTED 1173c8: e8 eb fe fe ff call 1072b8 <== NOT EXECUTED 1173cd: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED MSBUMP(malloc_calls, -1); /* subtract off the malloc */ 1173d0: ff 0d c4 f6 11 00 decl 0x11f6c4 <== NOT EXECUTED if ( !new_area ) { 1173d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1173d9: 85 c0 test %eax,%eax <== NOT EXECUTED 1173db: 74 d0 je 1173ad <== NOT EXECUTED return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 1173dd: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1173e0: 89 f1 mov %esi,%ecx <== NOT EXECUTED 1173e2: 39 c6 cmp %eax,%esi <== NOT EXECUTED 1173e4: 76 02 jbe 1173e8 <== NOT EXECUTED 1173e6: 89 c1 mov %eax,%ecx <== NOT EXECUTED 1173e8: 8b 7d dc mov -0x24(%ebp),%edi <== NOT EXECUTED 1173eb: 89 de mov %ebx,%esi <== NOT EXECUTED 1173ed: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED free( ptr ); 1173ef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1173f2: 53 push %ebx <== NOT EXECUTED 1173f3: e8 a8 fc fe ff call 1070a0 <== NOT EXECUTED 1173f8: 8b 5d dc mov -0x24(%ebp),%ebx <== NOT EXECUTED 1173fb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1173fe: e9 66 ff ff ff jmp 117369 <== NOT EXECUTED 00109de8 : #include void rewinddir( DIR *dirp ) { 109de8: 55 push %ebp <== NOT EXECUTED 109de9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109deb: 53 push %ebx <== NOT EXECUTED 109dec: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109def: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED off_t status; if ( !dirp ) 109df2: 85 db test %ebx,%ebx <== NOT EXECUTED 109df4: 74 19 je 109e0f <== NOT EXECUTED return; status = lseek( dirp->dd_fd, 0, SEEK_SET ); 109df6: 50 push %eax <== NOT EXECUTED 109df7: 6a 00 push $0x0 <== NOT EXECUTED 109df9: 6a 00 push $0x0 <== NOT EXECUTED 109dfb: ff 33 pushl (%ebx) <== NOT EXECUTED 109dfd: e8 a2 ee ff ff call 108ca4 <== NOT EXECUTED if( status == -1 ) 109e02: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109e05: 40 inc %eax <== NOT EXECUTED 109e06: 74 07 je 109e0f <== NOT EXECUTED return; dirp->dd_loc = 0; 109e08: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED } 109e0f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109e12: c9 leave <== NOT EXECUTED 109e13: c3 ret <== NOT EXECUTED 00125254 : #include int rmdir( const char *pathname ) { 125254: 55 push %ebp <== NOT EXECUTED 125255: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125257: 56 push %esi <== NOT EXECUTED 125258: 53 push %ebx <== NOT EXECUTED 125259: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( pathname, 0, &loc, false ); 12525c: 6a 00 push $0x0 <== NOT EXECUTED 12525e: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 125261: 56 push %esi <== NOT EXECUTED 125262: 6a 00 push $0x0 <== NOT EXECUTED 125264: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125267: e8 c0 5f fe ff call 10b22c <== NOT EXECUTED if ( result != 0 ) 12526c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12526f: 85 c0 test %eax,%eax <== NOT EXECUTED 125271: 74 11 je 125284 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.handlers->rmnod_h)( &loc ); rtems_filesystem_freenode( &loc ); 125273: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED return result; } 125278: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12527a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12527d: 5b pop %ebx <== NOT EXECUTED 12527e: 5e pop %esi <== NOT EXECUTED 12527f: c9 leave <== NOT EXECUTED 125280: c3 ret <== NOT EXECUTED 125281: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED result = rtems_filesystem_evaluate_path( pathname, 0, &loc, false ); if ( result != 0 ) return -1; result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc ); 125284: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 125287: 56 push %esi <== NOT EXECUTED 125288: 6a 02 push $0x2 <== NOT EXECUTED 12528a: e8 05 5f fe ff call 10b194 <== NOT EXECUTED if (result != 0) { 12528f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125292: 85 c0 test %eax,%eax <== NOT EXECUTED 125294: 0f 85 82 00 00 00 jne 12531c <== NOT EXECUTED /* * Verify you can remove this node as a directory. */ if ( !loc.ops->node_type_h ){ 12529a: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 12529d: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 1252a0: 85 c0 test %eax,%eax <== NOT EXECUTED 1252a2: 0f 84 a0 00 00 00 je 125348 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ){ 1252a8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1252ab: 56 push %esi <== NOT EXECUTED 1252ac: ff d0 call *%eax <== NOT EXECUTED 1252ae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1252b1: 48 dec %eax <== NOT EXECUTED 1252b2: 75 3c jne 1252f0 <== NOT EXECUTED /* * Use the filesystems rmnod to remove the node. */ if ( !loc.handlers->rmnod_h ){ 1252b4: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1252b7: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED 1252ba: 85 c0 test %eax,%eax <== NOT EXECUTED 1252bc: 0f 84 ab 00 00 00 je 12536d <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.handlers->rmnod_h)( &loc ); 1252c2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1252c5: 56 push %esi <== NOT EXECUTED 1252c6: ff d0 call *%eax <== NOT EXECUTED 1252c8: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1252ca: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1252cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1252d0: 85 c0 test %eax,%eax <== NOT EXECUTED 1252d2: 74 a4 je 125278 <== NOT EXECUTED 1252d4: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1252d7: 85 c0 test %eax,%eax <== NOT EXECUTED 1252d9: 74 9d je 125278 <== NOT EXECUTED 1252db: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1252de: 56 push %esi <== NOT EXECUTED 1252df: ff d0 call *%eax <== NOT EXECUTED 1252e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 1252e4: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1252e6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1252e9: 5b pop %ebx <== NOT EXECUTED 1252ea: 5e pop %esi <== NOT EXECUTED 1252eb: c9 leave <== NOT EXECUTED 1252ec: c3 ret <== NOT EXECUTED 1252ed: 8d 76 00 lea 0x0(%esi),%esi <== 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 ); 1252f0: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1252f3: 85 c0 test %eax,%eax <== NOT EXECUTED 1252f5: 74 10 je 125307 <== NOT EXECUTED 1252f7: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1252fa: 85 c0 test %eax,%eax <== NOT EXECUTED 1252fc: 74 09 je 125307 <== NOT EXECUTED 1252fe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125301: 56 push %esi <== NOT EXECUTED 125302: ff d0 call *%eax <== NOT EXECUTED 125304: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); 125307: e8 48 c5 00 00 call 131854 <__errno> <== NOT EXECUTED 12530c: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 125312: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 125317: e9 5c ff ff ff jmp 125278 <== NOT EXECUTED if ( result != 0 ) return -1; result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc ); if (result != 0) { rtems_filesystem_freenode( &loc ); 12531c: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 12531f: 85 c0 test %eax,%eax <== NOT EXECUTED 125321: 0f 84 4c ff ff ff je 125273 <== NOT EXECUTED 125327: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12532a: 85 c0 test %eax,%eax <== NOT EXECUTED 12532c: 0f 84 41 ff ff ff je 125273 <== NOT EXECUTED 125332: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125335: 56 push %esi <== NOT EXECUTED 125336: ff d0 call *%eax <== NOT EXECUTED 125338: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 12533d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125340: e9 33 ff ff ff jmp 125278 <== NOT EXECUTED 125345: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Verify you can remove this node as a directory. */ if ( !loc.ops->node_type_h ){ rtems_filesystem_freenode( &loc ); 125348: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 12534b: 85 c0 test %eax,%eax <== NOT EXECUTED 12534d: 74 09 je 125358 <== NOT EXECUTED /* * Use the filesystems rmnod to remove the node. */ if ( !loc.handlers->rmnod_h ){ rtems_filesystem_freenode( &loc ); 12534f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125352: 56 push %esi <== NOT EXECUTED 125353: ff d0 call *%eax <== NOT EXECUTED 125355: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 125358: e8 f7 c4 00 00 call 131854 <__errno> <== NOT EXECUTED 12535d: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 125363: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 125368: e9 0b ff ff ff jmp 125278 <== NOT EXECUTED /* * Use the filesystems rmnod to remove the node. */ if ( !loc.handlers->rmnod_h ){ rtems_filesystem_freenode( &loc ); 12536d: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 125370: 85 c0 test %eax,%eax <== NOT EXECUTED 125372: 74 e4 je 125358 <== NOT EXECUTED 125374: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 125377: 85 c0 test %eax,%eax <== NOT EXECUTED 125379: 75 d4 jne 12534f <== NOT EXECUTED 12537b: eb db jmp 125358 <== NOT EXECUTED 0011039c : uint32_t rtems_assoc_local_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 11039c: 55 push %ebp <== NOT EXECUTED 11039d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11039f: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_remote(ap, remote_value); 1103a2: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1103a5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1103a8: e8 0f 00 00 00 call 1103bc <== NOT EXECUTED if (nap) 1103ad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1103b0: 85 c0 test %eax,%eax <== NOT EXECUTED 1103b2: 74 03 je 1103b7 <== NOT EXECUTED return nap->local_value; 1103b4: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED return 0; } 1103b7: c9 leave <== NOT EXECUTED 1103b8: c3 ret <== NOT EXECUTED 00110358 : uint32_t rtems_assoc_local_by_remote_bitfield( const rtems_assoc_t *ap, uint32_t remote_value ) { 110358: 55 push %ebp <== NOT EXECUTED 110359: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11035b: 57 push %edi <== NOT EXECUTED 11035c: 56 push %esi <== NOT EXECUTED 11035d: 53 push %ebx <== NOT EXECUTED 11035e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110361: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 110366: 31 ff xor %edi,%edi <== NOT EXECUTED 110368: 31 db xor %ebx,%ebx <== NOT EXECUTED 11036a: eb 08 jmp 110374 <== NOT EXECUTED uint32_t b; uint32_t local_value = 0; for (b = 1; b; b <<= 1) { 11036c: d1 e6 shl %esi <== NOT EXECUTED 11036e: 43 inc %ebx <== NOT EXECUTED 11036f: 83 fb 20 cmp $0x20,%ebx <== NOT EXECUTED 110372: 74 1e je 110392 <== NOT EXECUTED if (b & remote_value) 110374: 85 75 0c test %esi,0xc(%ebp) <== NOT EXECUTED 110377: 74 f3 je 11036c <== NOT EXECUTED local_value |= rtems_assoc_local_by_remote(ap, b); 110379: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11037c: 56 push %esi <== NOT EXECUTED 11037d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 110380: e8 17 00 00 00 call 11039c <== NOT EXECUTED 110385: 09 c7 or %eax,%edi <== NOT EXECUTED 110387: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { uint32_t b; uint32_t local_value = 0; for (b = 1; b; b <<= 1) { 11038a: d1 e6 shl %esi <== NOT EXECUTED 11038c: 43 inc %ebx <== NOT EXECUTED 11038d: 83 fb 20 cmp $0x20,%ebx <== NOT EXECUTED 110390: 75 e2 jne 110374 <== NOT EXECUTED if (b & remote_value) local_value |= rtems_assoc_local_by_remote(ap, b); } return local_value; } 110392: 89 f8 mov %edi,%eax <== NOT EXECUTED 110394: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 110397: 5b pop %ebx <== NOT EXECUTED 110398: 5e pop %esi <== NOT EXECUTED 110399: 5f pop %edi <== NOT EXECUTED 11039a: c9 leave <== NOT EXECUTED 11039b: c3 ret <== NOT EXECUTED 00118c4c : const char * rtems_assoc_name_bad( uint32_t bad_value ) { 118c4c: 55 push %ebp <== NOT EXECUTED 118c4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED sprintf(bad_buffer, "< %" PRId32 "[0x%" PRIx32 " ] >", bad_value, bad_value); #else static char bad_buffer[40] = ""; #endif return bad_buffer; } 118c4f: b8 00 b4 12 00 mov $0x12b400,%eax <== NOT EXECUTED 118c54: c9 leave <== NOT EXECUTED 118c55: c3 ret <== NOT EXECUTED 00114d80 : const char *rtems_assoc_name_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 114d80: 55 push %ebp <== NOT EXECUTED 114d81: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114d83: 53 push %ebx <== NOT EXECUTED 114d84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114d87: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 114d8a: 53 push %ebx <== NOT EXECUTED 114d8b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114d8e: e8 1d 00 00 00 call 114db0 <== NOT EXECUTED if (nap) 114d93: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114d96: 85 c0 test %eax,%eax <== NOT EXECUTED 114d98: 74 0a je 114da4 <== NOT EXECUTED return nap->name; 114d9a: 8b 00 mov (%eax),%eax <== NOT EXECUTED return rtems_assoc_name_bad(local_value); } 114d9c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114d9f: c9 leave <== NOT EXECUTED 114da0: c3 ret <== NOT EXECUTED 114da1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED nap = rtems_assoc_ptr_by_local(ap, local_value); if (nap) return nap->name; return rtems_assoc_name_bad(local_value); 114da4: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 114da7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114daa: c9 leave <== NOT EXECUTED nap = rtems_assoc_ptr_by_local(ap, local_value); if (nap) return nap->name; return rtems_assoc_name_bad(local_value); 114dab: e9 9c 3e 00 00 jmp 118c4c <== NOT EXECUTED 00110bdc : const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 110bdc: 55 push %ebp <== NOT EXECUTED 110bdd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110bdf: 57 push %edi <== NOT EXECUTED 110be0: 56 push %esi <== NOT EXECUTED 110be1: 53 push %ebx <== NOT EXECUTED 110be2: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 110be5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 110be8: 8b 33 mov (%ebx),%esi <== NOT EXECUTED 110bea: 85 f6 test %esi,%esi <== NOT EXECUTED 110bec: 74 4a je 110c38 <== NOT EXECUTED 110bee: bf 29 99 11 00 mov $0x119929,%edi <== NOT EXECUTED 110bf3: b9 0a 00 00 00 mov $0xa,%ecx <== NOT EXECUTED 110bf8: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 110bfa: 74 20 je 110c1c <== NOT EXECUTED 110bfc: 31 d2 xor %edx,%edx <== NOT EXECUTED 110bfe: eb 09 jmp 110c09 <== NOT EXECUTED default_ap = ap++; for ( ; ap->name; ap++) 110c00: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 110c03: 8b 0b mov (%ebx),%ecx <== NOT EXECUTED 110c05: 85 c9 test %ecx,%ecx <== NOT EXECUTED 110c07: 74 23 je 110c2c <== NOT EXECUTED if (ap->local_value == local_value) 110c09: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 110c0c: 39 43 04 cmp %eax,0x4(%ebx) <== NOT EXECUTED 110c0f: 75 ef jne 110c00 <== NOT EXECUTED return ap; return default_ap; } 110c11: 89 d8 mov %ebx,%eax <== NOT EXECUTED 110c13: 5a pop %edx <== NOT EXECUTED 110c14: 5b pop %ebx <== NOT EXECUTED 110c15: 5e pop %esi <== NOT EXECUTED 110c16: 5f pop %edi <== NOT EXECUTED 110c17: c9 leave <== NOT EXECUTED 110c18: c3 ret <== NOT EXECUTED 110c19: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 110c1c: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED for ( ; ap->name; ap++) 110c1f: 8b 73 0c mov 0xc(%ebx),%esi <== NOT EXECUTED 110c22: 85 f6 test %esi,%esi <== NOT EXECUTED 110c24: 74 eb je 110c11 <== NOT EXECUTED 110c26: 89 da mov %ebx,%edx <== NOT EXECUTED 110c28: 89 c3 mov %eax,%ebx <== NOT EXECUTED 110c2a: eb dd jmp 110c09 <== NOT EXECUTED 110c2c: 89 d3 mov %edx,%ebx <== NOT EXECUTED if (ap->local_value == local_value) return ap; return default_ap; } 110c2e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 110c30: 5a pop %edx <== NOT EXECUTED 110c31: 5b pop %ebx <== NOT EXECUTED 110c32: 5e pop %esi <== NOT EXECUTED 110c33: 5f pop %edi <== NOT EXECUTED 110c34: c9 leave <== NOT EXECUTED 110c35: c3 ret <== NOT EXECUTED 110c36: 66 90 xchg %ax,%ax <== NOT EXECUTED uint32_t local_value ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 110c38: 31 db xor %ebx,%ebx <== NOT EXECUTED for ( ; ap->name; ap++) if (ap->local_value == local_value) return ap; return default_ap; } 110c3a: 89 d8 mov %ebx,%eax <== NOT EXECUTED 110c3c: 5a pop %edx <== NOT EXECUTED 110c3d: 5b pop %ebx <== NOT EXECUTED 110c3e: 5e pop %esi <== NOT EXECUTED 110c3f: 5f pop %edi <== NOT EXECUTED 110c40: c9 leave <== NOT EXECUTED 110c41: c3 ret <== NOT EXECUTED 001103bc : const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 1103bc: 55 push %ebp <== NOT EXECUTED 1103bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1103bf: 57 push %edi <== NOT EXECUTED 1103c0: 56 push %esi <== NOT EXECUTED 1103c1: 53 push %ebx <== NOT EXECUTED 1103c2: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1103c5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 1103c8: 8b 33 mov (%ebx),%esi <== NOT EXECUTED 1103ca: 85 f6 test %esi,%esi <== NOT EXECUTED 1103cc: 74 4a je 110418 <== NOT EXECUTED 1103ce: bf 29 99 11 00 mov $0x119929,%edi <== NOT EXECUTED 1103d3: b9 0a 00 00 00 mov $0xa,%ecx <== NOT EXECUTED 1103d8: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 1103da: 74 20 je 1103fc <== NOT EXECUTED 1103dc: 31 d2 xor %edx,%edx <== NOT EXECUTED 1103de: eb 09 jmp 1103e9 <== NOT EXECUTED default_ap = ap++; for ( ; ap->name; ap++) 1103e0: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 1103e3: 8b 0b mov (%ebx),%ecx <== NOT EXECUTED 1103e5: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1103e7: 74 23 je 11040c <== NOT EXECUTED if (ap->remote_value == remote_value) 1103e9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1103ec: 39 43 08 cmp %eax,0x8(%ebx) <== NOT EXECUTED 1103ef: 75 ef jne 1103e0 <== NOT EXECUTED return ap; return default_ap; } 1103f1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1103f3: 5a pop %edx <== NOT EXECUTED 1103f4: 5b pop %ebx <== NOT EXECUTED 1103f5: 5e pop %esi <== NOT EXECUTED 1103f6: 5f pop %edi <== NOT EXECUTED 1103f7: c9 leave <== NOT EXECUTED 1103f8: c3 ret <== NOT EXECUTED 1103f9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 1103fc: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED for ( ; ap->name; ap++) 1103ff: 8b 73 0c mov 0xc(%ebx),%esi <== NOT EXECUTED 110402: 85 f6 test %esi,%esi <== NOT EXECUTED 110404: 74 eb je 1103f1 <== NOT EXECUTED 110406: 89 da mov %ebx,%edx <== NOT EXECUTED 110408: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11040a: eb dd jmp 1103e9 <== NOT EXECUTED 11040c: 89 d3 mov %edx,%ebx <== NOT EXECUTED if (ap->remote_value == remote_value) return ap; return default_ap; } 11040e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 110410: 5a pop %edx <== NOT EXECUTED 110411: 5b pop %ebx <== NOT EXECUTED 110412: 5e pop %esi <== NOT EXECUTED 110413: 5f pop %edi <== NOT EXECUTED 110414: c9 leave <== NOT EXECUTED 110415: c3 ret <== NOT EXECUTED 110416: 66 90 xchg %ax,%ax <== NOT EXECUTED uint32_t remote_value ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 110418: 31 db xor %ebx,%ebx <== NOT EXECUTED for ( ; ap->name; ap++) if (ap->remote_value == remote_value) return ap; return default_ap; } 11041a: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11041c: 5a pop %edx <== NOT EXECUTED 11041d: 5b pop %ebx <== NOT EXECUTED 11041e: 5e pop %esi <== NOT EXECUTED 11041f: 5f pop %edi <== NOT EXECUTED 110420: c9 leave <== NOT EXECUTED 110421: c3 ret <== NOT EXECUTED 00110424 : uint32_t rtems_assoc_remote_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 110424: 55 push %ebp <== NOT EXECUTED 110425: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110427: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 11042a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11042d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 110430: e8 a7 07 00 00 call 110bdc <== NOT EXECUTED if (nap) 110435: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110438: 85 c0 test %eax,%eax <== NOT EXECUTED 11043a: 74 03 je 11043f <== NOT EXECUTED return nap->remote_value; 11043c: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED return 0; } 11043f: c9 leave <== NOT EXECUTED 110440: c3 ret <== NOT EXECUTED 0010a748 : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 10a748: 55 push %ebp <== NOT EXECUTED 10a749: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a74b: 56 push %esi <== NOT EXECUTED 10a74c: 53 push %ebx <== NOT EXECUTED 10a74d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10a750: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 10a753: 85 f6 test %esi,%esi <== NOT EXECUTED 10a755: 0f 84 8d 00 00 00 je 10a7e8 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 10a75b: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10a75e: 85 d2 test %edx,%edx <== NOT EXECUTED 10a760: 0f 84 ba 00 00 00 je 10a820 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 10a766: f6 45 0c 10 testb $0x10,0xc(%ebp) <== NOT EXECUTED 10a76a: 0f 84 84 00 00 00 je 10a7f4 <== NOT EXECUTED the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 10a770: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10a773: 85 c0 test %eax,%eax <== NOT EXECUTED 10a775: 0f 84 85 00 00 00 je 10a800 <== NOT EXECUTED if ( !id ) return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10a77b: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; the_attributes.maximum_count = maximum_waiters; 10a782: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10a785: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a788: a1 98 27 12 00 mov 0x122798,%eax <== NOT EXECUTED 10a78d: 40 inc %eax <== NOT EXECUTED 10a78e: a3 98 27 12 00 mov %eax,0x122798 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10a793: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a796: 68 a0 26 12 00 push $0x1226a0 <== NOT EXECUTED 10a79b: e8 f4 1d 00 00 call 10c594 <_Objects_Allocate> <== NOT EXECUTED 10a7a0: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 10a7a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a7a5: 85 c0 test %eax,%eax <== NOT EXECUTED 10a7a7: 74 63 je 10a80c <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 10a7a9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a7ac: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 10a7af: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a7b2: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10a7b5: 50 push %eax <== NOT EXECUTED 10a7b6: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 10a7b9: 50 push %eax <== NOT EXECUTED 10a7ba: e8 01 15 00 00 call 10bcc0 <_CORE_barrier_Initialize> <== NOT EXECUTED 10a7bf: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10a7c2: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10a7c5: a1 bc 26 12 00 mov 0x1226bc,%eax <== NOT EXECUTED 10a7ca: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10a7cd: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 10a7d0: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a7d3: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a7d5: e8 f2 2a 00 00 call 10d2cc <_Thread_Enable_dispatch> <== NOT EXECUTED 10a7da: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a7dc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10a7df: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a7e2: 5b pop %ebx <== NOT EXECUTED 10a7e3: 5e pop %esi <== NOT EXECUTED 10a7e4: c9 leave <== NOT EXECUTED 10a7e5: c3 ret <== NOT EXECUTED 10a7e6: 66 90 xchg %ax,%ax <== NOT EXECUTED ) { Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 10a7e8: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a7ed: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a7f0: 5b pop %ebx <== NOT EXECUTED 10a7f1: 5e pop %esi <== NOT EXECUTED 10a7f2: c9 leave <== NOT EXECUTED 10a7f3: c3 ret <== NOT EXECUTED 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; 10a7f4: c7 45 f0 01 00 00 00 movl $0x1,-0x10(%ebp) <== NOT EXECUTED 10a7fb: eb 85 jmp 10a782 <== NOT EXECUTED 10a7fd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 10a800: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a805: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a808: 5b pop %ebx <== NOT EXECUTED 10a809: 5e pop %esi <== NOT EXECUTED 10a80a: c9 leave <== NOT EXECUTED 10a80b: c3 ret <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { _Thread_Enable_dispatch(); 10a80c: e8 bb 2a 00 00 call 10d2cc <_Thread_Enable_dispatch> <== NOT EXECUTED 10a811: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a816: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a819: 5b pop %ebx <== NOT EXECUTED 10a81a: 5e pop %esi <== NOT EXECUTED 10a81b: c9 leave <== NOT EXECUTED 10a81c: c3 ret <== NOT EXECUTED 10a81d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 10a820: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a825: eb b8 jmp 10a7df <== NOT EXECUTED 0010a828 : */ rtems_status_code rtems_barrier_delete( rtems_id id ) { 10a828: 55 push %ebp <== NOT EXECUTED 10a829: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a82b: 53 push %ebx <== NOT EXECUTED 10a82c: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap 10a82f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a832: 50 push %eax <== NOT EXECUTED 10a833: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a836: 68 a0 26 12 00 push $0x1226a0 <== NOT EXECUTED 10a83b: e8 48 22 00 00 call 10ca88 <_Objects_Get> <== NOT EXECUTED 10a840: 89 c3 mov %eax,%ebx <== NOT EXECUTED Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 10a842: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a845: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10a848: 85 c0 test %eax,%eax <== NOT EXECUTED 10a84a: 75 38 jne 10a884 <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_barrier_Flush( 10a84c: 50 push %eax <== NOT EXECUTED 10a84d: 6a 02 push $0x2 <== NOT EXECUTED 10a84f: 6a 00 push $0x0 <== NOT EXECUTED 10a851: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 10a854: 50 push %eax <== NOT EXECUTED 10a855: e8 7a 31 00 00 call 10d9d4 <_Thread_queue_Flush> <== NOT EXECUTED &the_barrier->Barrier, NULL, CORE_BARRIER_WAS_DELETED ); _Objects_Close( &_Barrier_Information, &the_barrier->Object ); 10a85a: 59 pop %ecx <== NOT EXECUTED 10a85b: 58 pop %eax <== NOT EXECUTED 10a85c: 53 push %ebx <== NOT EXECUTED 10a85d: 68 a0 26 12 00 push $0x1226a0 <== NOT EXECUTED 10a862: e8 ad 1d 00 00 call 10c614 <_Objects_Close> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 10a867: 58 pop %eax <== NOT EXECUTED 10a868: 5a pop %edx <== NOT EXECUTED 10a869: 53 push %ebx <== NOT EXECUTED 10a86a: 68 a0 26 12 00 push $0x1226a0 <== NOT EXECUTED 10a86f: e8 e0 20 00 00 call 10c954 <_Objects_Free> <== NOT EXECUTED _Barrier_Free( the_barrier ); _Thread_Enable_dispatch(); 10a874: e8 53 2a 00 00 call 10d2cc <_Thread_Enable_dispatch> <== NOT EXECUTED 10a879: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a87b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a87e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a881: c9 leave <== NOT EXECUTED 10a882: c3 ret <== NOT EXECUTED 10a883: 90 nop <== NOT EXECUTED { Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 10a884: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a889: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a88c: c9 leave <== NOT EXECUTED 10a88d: c3 ret <== NOT EXECUTED 0010a890 : rtems_status_code rtems_barrier_ident( rtems_name name, rtems_id *id ) { 10a890: 55 push %ebp <== NOT EXECUTED 10a891: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a893: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 10a896: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a899: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 10a89e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a8a1: 68 a0 26 12 00 push $0x1226a0 <== NOT EXECUTED 10a8a6: e8 35 23 00 00 call 10cbe0 <_Objects_Name_to_id_u32> <== NOT EXECUTED 10a8ab: 8b 04 85 74 c2 11 00 mov 0x11c274(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 10a8b2: c9 leave <== NOT EXECUTED 10a8b3: c3 ret <== NOT EXECUTED 0010a8b4 : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 10a8b4: 55 push %ebp <== NOT EXECUTED 10a8b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a8b7: 56 push %esi <== NOT EXECUTED 10a8b8: 53 push %ebx <== NOT EXECUTED 10a8b9: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10a8bc: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a8bf: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 10a8c2: 85 f6 test %esi,%esi <== NOT EXECUTED 10a8c4: 74 46 je 10a90c <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap 10a8c6: 50 push %eax <== NOT EXECUTED 10a8c7: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10a8ca: 50 push %eax <== NOT EXECUTED 10a8cb: 53 push %ebx <== NOT EXECUTED 10a8cc: 68 a0 26 12 00 push $0x1226a0 <== NOT EXECUTED 10a8d1: e8 b2 21 00 00 call 10ca88 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 10a8d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a8d9: 8b 4d f4 mov -0xc(%ebp),%ecx <== NOT EXECUTED 10a8dc: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a8de: 74 0c je 10a8ec <== NOT EXECUTED 10a8e0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a8e5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a8e8: 5b pop %ebx <== NOT EXECUTED 10a8e9: 5e pop %esi <== NOT EXECUTED 10a8ea: c9 leave <== NOT EXECUTED 10a8eb: c3 ret <== NOT EXECUTED the_barrier = _Barrier_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL ); 10a8ec: 52 push %edx <== NOT EXECUTED 10a8ed: 6a 00 push $0x0 <== NOT EXECUTED 10a8ef: 53 push %ebx <== NOT EXECUTED 10a8f0: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 10a8f3: 50 push %eax <== NOT EXECUTED 10a8f4: e8 fb 13 00 00 call 10bcf4 <_CORE_barrier_Release> <== NOT EXECUTED 10a8f9: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a8fb: e8 cc 29 00 00 call 10d2cc <_Thread_Enable_dispatch> <== NOT EXECUTED 10a900: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a902: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a905: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a908: 5b pop %ebx <== NOT EXECUTED 10a909: 5e pop %esi <== NOT EXECUTED 10a90a: c9 leave <== NOT EXECUTED 10a90b: c3 ret <== NOT EXECUTED ) { Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 10a90c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a911: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a914: 5b pop %ebx <== NOT EXECUTED 10a915: 5e pop %esi <== NOT EXECUTED 10a916: c9 leave <== NOT EXECUTED 10a917: c3 ret <== NOT EXECUTED 0010a918 : rtems_status_code rtems_barrier_wait( rtems_id id, rtems_interval timeout ) { 10a918: 55 push %ebp <== NOT EXECUTED 10a919: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a91b: 53 push %ebx <== NOT EXECUTED 10a91c: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10a91f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a922: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a925: 50 push %eax <== NOT EXECUTED 10a926: 53 push %ebx <== NOT EXECUTED 10a927: 68 a0 26 12 00 push $0x1226a0 <== NOT EXECUTED 10a92c: e8 57 21 00 00 call 10ca88 <_Objects_Get> <== NOT EXECUTED Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 10a931: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a934: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10a937: 85 d2 test %edx,%edx <== NOT EXECUTED 10a939: 75 35 jne 10a970 <== NOT EXECUTED case OBJECTS_LOCAL: _CORE_barrier_Wait( 10a93b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a93e: 6a 00 push $0x0 <== NOT EXECUTED 10a940: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a943: 6a 01 push $0x1 <== NOT EXECUTED 10a945: 53 push %ebx <== NOT EXECUTED 10a946: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 10a949: 50 push %eax <== NOT EXECUTED 10a94a: e8 d5 13 00 00 call 10bd24 <_CORE_barrier_Wait> <== NOT EXECUTED id, TRUE, timeout, NULL ); _Thread_Enable_dispatch(); 10a94f: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a952: e8 75 29 00 00 call 10d2cc <_Thread_Enable_dispatch> <== NOT EXECUTED return _Barrier_Translate_core_barrier_return_code( 10a957: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a95a: a1 5c 28 12 00 mov 0x12285c,%eax <== NOT EXECUTED 10a95f: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10a962: e8 65 59 00 00 call 1102cc <_Barrier_Translate_core_barrier_return_code> <== NOT EXECUTED 10a967: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a96a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a96d: c9 leave <== NOT EXECUTED 10a96e: c3 ret <== NOT EXECUTED 10a96f: 90 nop <== NOT EXECUTED { Barrier_Control *the_barrier; Objects_Locations location; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 10a970: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a975: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a978: c9 leave <== NOT EXECUTED 10a979: c3 ret <== NOT EXECUTED 0010b668 : uint32_t api, uint32_t class, uint32_t node, uint32_t index ) { 10b668: 55 push %ebp <== NOT EXECUTED 10b669: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b66b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b66e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b671: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10b674: c1 e0 1b shl $0x1b,%eax <== NOT EXECUTED 10b677: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10b67a: 09 d0 or %edx,%eax <== NOT EXECUTED 10b67c: 0b 45 14 or 0x14(%ebp),%eax <== NOT EXECUTED 10b67f: c1 e1 10 shl $0x10,%ecx <== NOT EXECUTED 10b682: 09 c8 or %ecx,%eax <== NOT EXECUTED return _Objects_Build_id( api, class, node, index ); } 10b684: c9 leave <== NOT EXECUTED 10b685: c3 ret <== NOT EXECUTED 0010b688 : char C1, char C2, char C3, char C4 ) { 10b688: 55 push %ebp <== NOT EXECUTED 10b689: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b68b: 0f be 45 0c movsbl 0xc(%ebp),%eax <== NOT EXECUTED 10b68f: c1 e0 10 shl $0x10,%eax <== NOT EXECUTED 10b692: 0f be 55 08 movsbl 0x8(%ebp),%edx <== NOT EXECUTED 10b696: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10b699: 09 d0 or %edx,%eax <== NOT EXECUTED 10b69b: 0f be 55 10 movsbl 0x10(%ebp),%edx <== NOT EXECUTED 10b69f: c1 e2 08 shl $0x8,%edx <== NOT EXECUTED 10b6a2: 09 d0 or %edx,%eax <== NOT EXECUTED 10b6a4: 0f be 55 14 movsbl 0x14(%ebp),%edx <== NOT EXECUTED 10b6a8: 09 d0 or %edx,%eax <== NOT EXECUTED return _Objects_Build_name( C1, C2, C3, C4 ); } 10b6aa: c9 leave <== NOT EXECUTED 10b6ab: c3 ret <== NOT EXECUTED 00109acc : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 109acc: 55 push %ebp <== NOT EXECUTED 109acd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109acf: 53 push %ebx <== NOT EXECUTED 109ad0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109ad3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109ad6: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED if ( !time_buffer ) 109ad9: 85 db test %ebx,%ebx <== NOT EXECUTED 109adb: 74 5b je 109b38 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; switch ( option ) { 109add: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 109ae0: 76 0a jbe 109aec <== NOT EXECUTED 109ae2: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 109ae7: 5a pop %edx <== NOT EXECUTED 109ae8: 5b pop %ebx <== NOT EXECUTED 109ae9: c9 leave <== NOT EXECUTED 109aea: c3 ret <== NOT EXECUTED 109aeb: 90 nop <== NOT EXECUTED ) { if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; switch ( option ) { 109aec: ff 24 85 e8 8f 11 00 jmp *0x118fe8(,%eax,4) <== NOT EXECUTED 109af3: 90 nop <== NOT EXECUTED *interval = rtems_clock_get_ticks_per_second(); return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_TIME_VALUE: return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 109af4: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 109af7: 59 pop %ecx <== NOT EXECUTED 109af8: 5b pop %ebx <== NOT EXECUTED 109af9: c9 leave <== NOT EXECUTED *interval = rtems_clock_get_ticks_per_second(); return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_TIME_VALUE: return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 109afa: e9 3d 01 00 00 jmp 109c3c <== NOT EXECUTED 109aff: 90 nop <== NOT EXECUTED return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_TICKS_PER_SECOND: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_per_second(); 109b00: e8 6b 00 00 00 call 109b70 <== NOT EXECUTED 109b05: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 109b07: 31 c0 xor %eax,%eax <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 109b09: 5a pop %edx <== NOT EXECUTED 109b0a: 5b pop %ebx <== NOT EXECUTED 109b0b: c9 leave <== NOT EXECUTED 109b0c: c3 ret <== NOT EXECUTED 109b0d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); case RTEMS_CLOCK_GET_TICKS_SINCE_BOOT: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_since_boot(); 109b10: e8 6f 00 00 00 call 109b84 <== NOT EXECUTED 109b15: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 109b17: 31 c0 xor %eax,%eax <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 109b19: 5a pop %edx <== NOT EXECUTED 109b1a: 5b pop %ebx <== NOT EXECUTED 109b1b: c9 leave <== NOT EXECUTED 109b1c: c3 ret <== NOT EXECUTED 109b1d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED switch ( option ) { case RTEMS_CLOCK_GET_TOD: return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH: return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); 109b20: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 109b23: 5b pop %ebx <== NOT EXECUTED 109b24: 5b pop %ebx <== NOT EXECUTED 109b25: c9 leave <== NOT EXECUTED switch ( option ) { case RTEMS_CLOCK_GET_TOD: return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); case RTEMS_CLOCK_GET_SECONDS_SINCE_EPOCH: return rtems_clock_get_seconds_since_epoch((rtems_interval *)time_buffer); 109b26: e9 15 00 00 00 jmp 109b40 <== NOT EXECUTED 109b2b: 90 nop <== NOT EXECUTED if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; switch ( option ) { case RTEMS_CLOCK_GET_TOD: return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 109b2c: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED break; } return RTEMS_INVALID_NUMBER; } 109b2f: 58 pop %eax <== NOT EXECUTED 109b30: 5b pop %ebx <== NOT EXECUTED 109b31: c9 leave <== NOT EXECUTED if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; switch ( option ) { case RTEMS_CLOCK_GET_TOD: return rtems_clock_get_tod( (rtems_time_of_day *)time_buffer ); 109b32: e9 59 00 00 00 jmp 109b90 <== NOT EXECUTED 109b37: 90 nop <== NOT EXECUTED rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { if ( !time_buffer ) 109b38: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109b3d: eb a8 jmp 109ae7 <== NOT EXECUTED 00109b40 : #include rtems_status_code rtems_clock_get_seconds_since_epoch( rtems_interval *the_interval ) { 109b40: 55 push %ebp <== NOT EXECUTED 109b41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109b43: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED if ( !the_interval ) 109b46: 85 d2 test %edx,%edx <== NOT EXECUTED 109b48: 74 1e je 109b68 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 109b4a: 80 3d cc f7 11 00 00 cmpb $0x0,0x11f7cc <== NOT EXECUTED 109b51: 74 0d je 109b60 <== NOT EXECUTED return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch; 109b53: a1 4c f8 11 00 mov 0x11f84c,%eax <== NOT EXECUTED 109b58: 89 02 mov %eax,(%edx) <== NOT EXECUTED 109b5a: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109b5c: c9 leave <== NOT EXECUTED 109b5d: c3 ret <== NOT EXECUTED 109b5e: 66 90 xchg %ax,%ax <== NOT EXECUTED ) { if ( !the_interval ) return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 109b60: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch; return RTEMS_SUCCESSFUL; } 109b65: c9 leave <== NOT EXECUTED 109b66: c3 ret <== NOT EXECUTED 109b67: 90 nop <== NOT EXECUTED rtems_status_code rtems_clock_get_seconds_since_epoch( rtems_interval *the_interval ) { if ( !the_interval ) 109b68: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch; return RTEMS_SUCCESSFUL; } 109b6d: c9 leave <== NOT EXECUTED 109b6e: c3 ret <== NOT EXECUTED 00109b70 : #include #include #include rtems_interval rtems_clock_get_ticks_per_second(void) { 109b70: 55 push %ebp <== NOT EXECUTED 109b71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109b73: b8 40 42 0f 00 mov $0xf4240,%eax <== NOT EXECUTED 109b78: 31 d2 xor %edx,%edx <== NOT EXECUTED 109b7a: f7 35 80 f9 11 00 divl 0x11f980 <== NOT EXECUTED return TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick; } 109b80: c9 leave <== NOT EXECUTED 109b81: c3 ret <== NOT EXECUTED 00109b84 : #include #include #include rtems_interval rtems_clock_get_ticks_since_boot(void) { 109b84: 55 push %ebp <== NOT EXECUTED 109b85: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Watchdog_Ticks_since_boot; 109b87: a1 24 f9 11 00 mov 0x11f924,%eax <== NOT EXECUTED } 109b8c: c9 leave <== NOT EXECUTED 109b8d: c3 ret <== NOT EXECUTED 00109b90 : #include rtems_status_code rtems_clock_get_tod( rtems_time_of_day *time_buffer ) { 109b90: 55 push %ebp <== NOT EXECUTED 109b91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109b93: 56 push %esi <== NOT EXECUTED 109b94: 53 push %ebx <== NOT EXECUTED 109b95: 83 ec 40 sub $0x40,%esp <== NOT EXECUTED 109b98: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED rtems_time_of_day *tmbuf = time_buffer; struct tm time; struct timeval now; if ( !time_buffer ) 109b9b: 85 f6 test %esi,%esi <== NOT EXECUTED 109b9d: 0f 84 8d 00 00 00 je 109c30 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 109ba3: 80 3d cc f7 11 00 00 cmpb $0x0,0x11f7cc <== NOT EXECUTED 109baa: 75 0c jne 109bb8 <== NOT EXECUTED 109bac: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; return RTEMS_SUCCESSFUL; } 109bb1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109bb4: 5b pop %ebx <== NOT EXECUTED 109bb5: 5e pop %esi <== NOT EXECUTED 109bb6: c9 leave <== NOT EXECUTED 109bb7: c3 ret <== NOT EXECUTED ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 109bb8: 9c pushf <== NOT EXECUTED 109bb9: fa cli <== NOT EXECUTED 109bba: 5b pop %ebx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 109bbb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109bbe: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 109bc1: 50 push %eax <== NOT EXECUTED 109bc2: e8 d5 16 00 00 call 10b29c <_TOD_Get> <== NOT EXECUTED * begin at @a starting_address. 109bc7: 53 push %ebx <== NOT EXECUTED 109bc8: 9d popf <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon 109bc9: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 109bcc: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory 109bcf: b8 d3 4d 62 10 mov $0x10624dd3,%eax <== NOT EXECUTED 109bd4: f7 65 ec mull -0x14(%ebp) <== NOT EXECUTED 109bd7: c1 ea 06 shr $0x6,%edx <== NOT EXECUTED 109bda: 89 55 f4 mov %edx,-0xc(%ebp) <== NOT EXECUTED /* Obtain the current time */ _TOD_Get_timeval( &now ); /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); 109bdd: 58 pop %eax <== NOT EXECUTED 109bde: 5a pop %edx <== NOT EXECUTED 109bdf: 8d 45 c4 lea -0x3c(%ebp),%eax <== NOT EXECUTED 109be2: 50 push %eax <== NOT EXECUTED 109be3: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 109be6: 50 push %eax <== NOT EXECUTED 109be7: e8 dc 77 00 00 call 1113c8 <== NOT EXECUTED /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 109bec: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 109bef: 05 6c 07 00 00 add $0x76c,%eax <== NOT EXECUTED 109bf4: 89 06 mov %eax,(%esi) <== NOT EXECUTED tmbuf->month = time.tm_mon + 1; 109bf6: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 109bf9: 40 inc %eax <== NOT EXECUTED 109bfa: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED tmbuf->day = time.tm_mday; 109bfd: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 109c00: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED tmbuf->hour = time.tm_hour; 109c03: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 109c06: 89 46 0c mov %eax,0xc(%esi) <== NOT EXECUTED tmbuf->minute = time.tm_min; 109c09: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 109c0c: 89 46 10 mov %eax,0x10(%esi) <== NOT EXECUTED tmbuf->second = time.tm_sec; 109c0f: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED 109c12: 89 46 14 mov %eax,0x14(%esi) <== NOT EXECUTED tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 109c15: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 109c18: 31 d2 xor %edx,%edx <== NOT EXECUTED 109c1a: f7 35 80 f9 11 00 divl 0x11f980 <== NOT EXECUTED 109c20: 89 46 18 mov %eax,0x18(%esi) <== NOT EXECUTED 109c23: 31 c0 xor %eax,%eax <== NOT EXECUTED 109c25: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109c28: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109c2b: 5b pop %ebx <== NOT EXECUTED 109c2c: 5e pop %esi <== NOT EXECUTED 109c2d: c9 leave <== NOT EXECUTED 109c2e: c3 ret <== NOT EXECUTED 109c2f: 90 nop <== NOT EXECUTED { rtems_time_of_day *tmbuf = time_buffer; struct tm time; struct timeval now; if ( !time_buffer ) 109c30: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109c35: e9 77 ff ff ff jmp 109bb1 <== NOT EXECUTED 00109c3c : #include rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { 109c3c: 55 push %ebp <== NOT EXECUTED 109c3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109c3f: 56 push %esi <== NOT EXECUTED 109c40: 53 push %ebx <== NOT EXECUTED 109c41: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 109c44: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED if ( !time ) 109c47: 85 f6 test %esi,%esi <== NOT EXECUTED 109c49: 74 45 je 109c90 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 109c4b: 80 3d cc f7 11 00 00 cmpb $0x0,0x11f7cc <== NOT EXECUTED 109c52: 75 0c jne 109c60 <== NOT EXECUTED 109c54: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; } 109c59: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109c5c: 5b pop %ebx <== NOT EXECUTED 109c5d: 5e pop %esi <== NOT EXECUTED 109c5e: c9 leave <== NOT EXECUTED 109c5f: c3 ret <== NOT EXECUTED ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 109c60: 9c pushf <== NOT EXECUTED 109c61: fa cli <== NOT EXECUTED 109c62: 5b pop %ebx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 109c63: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109c66: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 109c69: 50 push %eax <== NOT EXECUTED 109c6a: e8 2d 16 00 00 call 10b29c <_TOD_Get> <== NOT EXECUTED * begin at @a starting_address. 109c6f: 53 push %ebx <== NOT EXECUTED 109c70: 9d popf <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon 109c71: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 109c74: 89 06 mov %eax,(%esi) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory 109c76: b8 d3 4d 62 10 mov $0x10624dd3,%eax <== NOT EXECUTED 109c7b: f7 65 f4 mull -0xc(%ebp) <== NOT EXECUTED 109c7e: c1 ea 06 shr $0x6,%edx <== NOT EXECUTED 109c81: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED 109c84: 31 c0 xor %eax,%eax <== NOT EXECUTED 109c86: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109c89: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109c8c: 5b pop %ebx <== NOT EXECUTED 109c8d: 5e pop %esi <== NOT EXECUTED 109c8e: c9 leave <== NOT EXECUTED 109c8f: c3 ret <== NOT EXECUTED rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { if ( !time ) 109c90: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109c95: eb c2 jmp 109c59 <== NOT EXECUTED 00109e90 : * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { 109e90: 55 push %ebp <== NOT EXECUTED 109e91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109e93: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109e96: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !uptime ) 109e99: 85 c0 test %eax,%eax <== NOT EXECUTED 109e9b: 74 13 je 109eb0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime( uptime ); 109e9d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109ea0: 50 push %eax <== NOT EXECUTED 109ea1: e8 a2 17 00 00 call 10b648 <_TOD_Get_uptime> <== NOT EXECUTED 109ea6: 31 c0 xor %eax,%eax <== NOT EXECUTED 109ea8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109eab: c9 leave <== NOT EXECUTED 109eac: c3 ret <== NOT EXECUTED 109ead: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { if ( !uptime ) 109eb0: b0 09 mov $0x9,%al <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime( uptime ); return RTEMS_SUCCESSFUL; } 109eb2: c9 leave <== NOT EXECUTED 109eb3: c3 ret <== NOT EXECUTED 0010ab5c : */ rtems_status_code rtems_clock_set( rtems_time_of_day *time_buffer ) { 10ab5c: 55 push %ebp <== NOT EXECUTED 10ab5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ab5f: 53 push %ebx <== NOT EXECUTED 10ab60: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10ab63: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED struct timespec newtime; if ( !time_buffer ) 10ab66: 85 db test %ebx,%ebx <== NOT EXECUTED 10ab68: 74 66 je 10abd0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { 10ab6a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab6d: 53 push %ebx <== NOT EXECUTED 10ab6e: e8 3d 01 00 00 call 10acb0 <_TOD_Validate> <== NOT EXECUTED 10ab73: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab76: 84 c0 test %al,%al <== NOT EXECUTED 10ab78: 75 0a jne 10ab84 <== NOT EXECUTED 10ab7a: b8 14 00 00 00 mov $0x14,%eax <== NOT EXECUTED _TOD_Set( &newtime ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 10ab7f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ab82: c9 leave <== NOT EXECUTED 10ab83: c3 ret <== NOT EXECUTED if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { newtime.tv_sec = _TOD_To_seconds( time_buffer ); 10ab84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab87: 53 push %ebx <== NOT EXECUTED 10ab88: e8 93 00 00 00 call 10ac20 <_TOD_To_seconds> <== NOT EXECUTED 10ab8d: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED newtime.tv_nsec = time_buffer->ticks * 10ab90: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10ab93: 0f af 05 a0 b9 12 00 imul 0x12b9a0,%eax <== NOT EXECUTED 10ab9a: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10ab9d: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10aba0: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10aba3: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 10aba6: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10aba9: a1 d8 b7 12 00 mov 0x12b7d8,%eax <== NOT EXECUTED 10abae: 40 inc %eax <== NOT EXECUTED 10abaf: a3 d8 b7 12 00 mov %eax,0x12b7d8 <== NOT EXECUTED (_TOD_Microseconds_per_tick * TOD_NANOSECONDS_PER_MICROSECOND); _Thread_Disable_dispatch(); _TOD_Set( &newtime ); 10abb4: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10abb7: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10abba: e8 6d 1a 00 00 call 10c62c <_TOD_Set> <== NOT EXECUTED _Thread_Enable_dispatch(); 10abbf: e8 54 2c 00 00 call 10d818 <_Thread_Enable_dispatch> <== NOT EXECUTED 10abc4: 31 c0 xor %eax,%eax <== NOT EXECUTED 10abc6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 10abc9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10abcc: c9 leave <== NOT EXECUTED 10abcd: c3 ret <== NOT EXECUTED 10abce: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_time_of_day *time_buffer ) { struct timespec newtime; if ( !time_buffer ) 10abd0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED _TOD_Set( &newtime ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 10abd5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10abd8: c9 leave <== NOT EXECUTED 10abd9: c3 ret <== NOT EXECUTED 00109c98 : * error code - if unsuccessful */ rtems_status_code rtems_clock_set_nanoseconds_extension( rtems_nanoseconds_extension_routine routine ) { 109c98: 55 push %ebp <== NOT EXECUTED 109c99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109c9b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !routine ) 109c9e: 85 c0 test %eax,%eax <== NOT EXECUTED 109ca0: 74 0a je 109cac <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _Watchdog_Nanoseconds_since_tick_handler = routine; 109ca2: a3 88 f9 11 00 mov %eax,0x11f988 <== NOT EXECUTED 109ca7: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109ca9: c9 leave <== NOT EXECUTED 109caa: c3 ret <== NOT EXECUTED 109cab: 90 nop <== NOT EXECUTED */ rtems_status_code rtems_clock_set_nanoseconds_extension( rtems_nanoseconds_extension_routine routine ) { if ( !routine ) 109cac: b0 09 mov $0x9,%al <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _Watchdog_Nanoseconds_since_tick_handler = routine; return RTEMS_SUCCESSFUL; } 109cae: c9 leave <== NOT EXECUTED 109caf: c3 ret <== NOT EXECUTED 00109cb0 : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 109cb0: 55 push %ebp <== NOT EXECUTED 109cb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109cb3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED _TOD_Tickle_ticks(); 109cb6: e8 71 16 00 00 call 10b32c <_TOD_Tickle_ticks> <== NOT EXECUTED * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. * Any other value of @a alignment is taken "as is", i.e., even odd * alignments are possible. * Returns pointer to the start of the memory block if success, NULL if 109cbb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109cbe: 68 9c f8 11 00 push $0x11f89c <== NOT EXECUTED 109cc3: e8 30 37 00 00 call 10d3f8 <_Watchdog_Tickle> <== NOT EXECUTED _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 109cc8: e8 db 31 00 00 call 10cea8 <_Thread_Tickle_timeslice> <== NOT EXECUTED 109ccd: a0 8c f8 11 00 mov 0x11f88c,%al <== NOT EXECUTED if ( _Thread_Is_context_switch_necessary() && 109cd2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109cd5: 84 c0 test %al,%al <== NOT EXECUTED 109cd7: 74 09 je 109ce2 <== NOT EXECUTED 109cd9: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 109cde: 85 c0 test %eax,%eax <== NOT EXECUTED 109ce0: 74 06 je 109ce8 <== NOT EXECUTED _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); return RTEMS_SUCCESSFUL; } 109ce2: 31 c0 xor %eax,%eax <== NOT EXECUTED 109ce4: c9 leave <== NOT EXECUTED 109ce5: c3 ret <== NOT EXECUTED 109ce6: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_Tickle_timeslice(); if ( _Thread_Is_context_switch_necessary() && _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 109ce8: e8 03 25 00 00 call 10c1f0 <_Thread_Dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109ced: 31 c0 xor %eax,%eax <== NOT EXECUTED 109cef: c9 leave <== NOT EXECUTED 109cf0: c3 ret <== NOT EXECUTED 001078f4 : void rtems_cpu_usage_report( void ) { 1078f4: 55 push %ebp <== NOT EXECUTED 1078f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1078f7: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_cpu_usage_report_with_plugin( NULL, printk_plugin ); 1078fa: 68 a0 8c 10 00 push $0x108ca0 <== NOT EXECUTED 1078ff: 6a 00 push $0x0 <== NOT EXECUTED 107901: e8 82 fe ff ff call 107788 <== NOT EXECUTED 107906: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 107909: c9 leave <== NOT EXECUTED 10790a: c3 ret <== NOT EXECUTED 00107788 : void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) { 107788: 55 push %ebp <== NOT EXECUTED 107789: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10778b: 57 push %edi <== NOT EXECUTED 10778c: 56 push %esi <== NOT EXECUTED 10778d: 53 push %ebx <== NOT EXECUTED 10778e: 83 ec 4c sub $0x4c,%esp <== NOT EXECUTED struct timespec uptime, total, ran; #else uint32_t total_units = 0; #endif if ( !print ) 107791: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 107794: 85 c9 test %ecx,%ecx <== NOT EXECUTED 107796: 0f 84 4e 01 00 00 je 1078ea <== NOT EXECUTED * When not using nanosecond CPU usage resolution, we have to count * the number of "ticks" we gave credit for to give the user a rough * guideline as to what each number means proportionally. */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _TOD_Get_uptime( &uptime ); 10779c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10779f: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 1077a2: 50 push %eax <== NOT EXECUTED 1077a3: e8 f4 4d 00 00 call 10c59c <_TOD_Get_uptime> <== NOT EXECUTED _Timespec_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total ); 1077a8: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1077ab: 8d 55 dc lea -0x24(%ebp),%edx <== NOT EXECUTED 1077ae: 52 push %edx <== NOT EXECUTED 1077af: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 1077b2: 50 push %eax <== NOT EXECUTED 1077b3: 68 ec bd 12 00 push $0x12bdec <== NOT EXECUTED 1077b8: e8 43 6f 00 00 call 10e700 <_Timespec_Subtract> <== NOT EXECUTED } } } #endif (*print)( context, "CPU Usage by thread\n" 1077bd: 58 pop %eax <== NOT EXECUTED 1077be: 5a pop %edx <== NOT EXECUTED 1077bf: 68 14 c0 11 00 push $0x11c014 <== NOT EXECUTED 1077c4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1077c7: ff 55 0c call *0xc(%ebp) <== NOT EXECUTED 1077ca: c7 45 b0 01 00 00 00 movl $0x1,-0x50(%ebp) <== NOT EXECUTED 1077d1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 1077d4: 8b 55 b0 mov -0x50(%ebp),%edx <== NOT EXECUTED 1077d7: 8b 04 95 ac b7 12 00 mov 0x12b7ac(,%edx,4),%eax <== NOT EXECUTED 1077de: 85 c0 test %eax,%eax <== NOT EXECUTED 1077e0: 0f 84 da 00 00 00 je 1078c0 <== NOT EXECUTED continue; information = _Objects_Information_table[ api_index ][ 1 ]; 1077e6: 8b 78 04 mov 0x4(%eax),%edi <== NOT EXECUTED if ( information ) { 1077e9: 85 ff test %edi,%edi <== NOT EXECUTED 1077eb: 0f 84 cf 00 00 00 je 1078c0 <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { 1077f1: 66 83 7f 10 00 cmpw $0x0,0x10(%edi) <== NOT EXECUTED 1077f6: 0f 84 c4 00 00 00 je 1078c0 <== NOT EXECUTED 1077fc: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 107801: eb 44 jmp 107847 <== NOT EXECUTED 107803: 90 nop <== NOT EXECUTED 107804: 8d 5d d4 lea -0x2c(%ebp),%ebx <== NOT EXECUTED _Timespec_Subtract( &_Thread_Time_of_last_context_switch, &uptime, &used ); _Timespec_Add_to( &ran, &used ); }; _Timespec_Divide( &ran, &total, &ival, &fval ); 107807: 8d 55 ec lea -0x14(%ebp),%edx <== NOT EXECUTED 10780a: 52 push %edx <== NOT EXECUTED 10780b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10780e: 50 push %eax <== NOT EXECUTED 10780f: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 107812: 50 push %eax <== NOT EXECUTED 107813: 53 push %ebx <== NOT EXECUTED 107814: e8 1f 6e 00 00 call 10e638 <_Timespec_Divide> <== NOT EXECUTED /* * Print the information */ (*print)( context, 107819: 58 pop %eax <== NOT EXECUTED 10781a: 5a pop %edx <== NOT EXECUTED 10781b: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10781e: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 107821: b8 d3 4d 62 10 mov $0x10624dd3,%eax <== NOT EXECUTED 107826: f7 65 d8 mull -0x28(%ebp) <== NOT EXECUTED 107829: c1 ea 06 shr $0x6,%edx <== NOT EXECUTED 10782c: 52 push %edx <== NOT EXECUTED 10782d: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 107830: 68 a2 c0 11 00 push $0x11c0a2 <== NOT EXECUTED 107835: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107838: ff 55 0c call *0xc(%ebp) <== NOT EXECUTED 10783b: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 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++ ) { 10783e: 46 inc %esi <== NOT EXECUTED 10783f: 0f b7 47 10 movzwl 0x10(%edi),%eax <== NOT EXECUTED 107843: 39 f0 cmp %esi,%eax <== NOT EXECUTED 107845: 72 79 jb 1078c0 <== NOT EXECUTED the_thread = (Thread_Control *)information->local_table[ i ]; 107847: 8b 47 1c mov 0x1c(%edi),%eax <== NOT EXECUTED 10784a: 8b 1c b0 mov (%eax,%esi,4),%ebx <== NOT EXECUTED if ( !the_thread ) 10784d: 85 db test %ebx,%ebx <== NOT EXECUTED 10784f: 74 ed je 10783e <== NOT EXECUTED continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 107851: 50 push %eax <== NOT EXECUTED 107852: 8d 45 bf lea -0x41(%ebp),%eax <== NOT EXECUTED 107855: 50 push %eax <== NOT EXECUTED 107856: 6a 0d push $0xd <== NOT EXECUTED 107858: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10785b: e8 fc 38 00 00 call 10b15c <== NOT EXECUTED (*print)( 107860: 8d 55 bf lea -0x41(%ebp),%edx <== NOT EXECUTED 107863: 52 push %edx <== NOT EXECUTED 107864: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 107867: 68 8f c0 11 00 push $0x11c08f <== NOT EXECUTED 10786c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10786f: ff 55 0c call *0xc(%ebp) <== NOT EXECUTED #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; 107872: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx <== NOT EXECUTED 107878: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax <== NOT EXECUTED 10787e: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED 107881: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED if ( _Thread_Executing->Object.id == the_thread->Object.id ) { 107884: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 107887: a1 9c b8 12 00 mov 0x12b89c,%eax <== NOT EXECUTED 10788c: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10788f: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 107892: 0f 85 6c ff ff ff jne 107804 <== NOT EXECUTED struct timespec used; _Timespec_Subtract( 107898: 50 push %eax <== NOT EXECUTED 107899: 8d 5d cc lea -0x34(%ebp),%ebx <== NOT EXECUTED 10789c: 53 push %ebx <== NOT EXECUTED 10789d: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 1078a0: 50 push %eax <== NOT EXECUTED 1078a1: 68 a4 b8 12 00 push $0x12b8a4 <== NOT EXECUTED 1078a6: e8 55 6e 00 00 call 10e700 <_Timespec_Subtract> <== NOT EXECUTED &_Thread_Time_of_last_context_switch, &uptime, &used ); _Timespec_Add_to( &ran, &used ); 1078ab: 59 pop %ecx <== NOT EXECUTED 1078ac: 58 pop %eax <== NOT EXECUTED 1078ad: 53 push %ebx <== NOT EXECUTED 1078ae: 8d 5d d4 lea -0x2c(%ebp),%ebx <== NOT EXECUTED 1078b1: 53 push %ebx <== NOT EXECUTED 1078b2: e8 49 6d 00 00 call 10e600 <_Timespec_Add_to> <== NOT EXECUTED 1078b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1078ba: e9 48 ff ff ff jmp 107807 <== NOT EXECUTED 1078bf: 90 nop <== NOT EXECUTED #endif ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 1078c0: ff 45 b0 incl -0x50(%ebp) <== NOT EXECUTED " ID NAME TICKS PERCENT\n" #endif ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 1078c3: 83 7d b0 05 cmpl $0x5,-0x50(%ebp) <== NOT EXECUTED 1078c7: 0f 85 07 ff ff ff jne 1077d4 <== NOT EXECUTED } } } #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS (*print)( context, "Time since last CPU Usage reset %" PRId32 1078cd: b8 d3 4d 62 10 mov $0x10624dd3,%eax <== NOT EXECUTED 1078d2: f7 65 e0 mull -0x20(%ebp) <== NOT EXECUTED 1078d5: c1 ea 06 shr $0x6,%edx <== NOT EXECUTED 1078d8: 52 push %edx <== NOT EXECUTED 1078d9: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED 1078dc: 68 5c c0 11 00 push $0x11c05c <== NOT EXECUTED 1078e1: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1078e4: ff 55 0c call *0xc(%ebp) <== NOT EXECUTED 1078e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED "Ticks since last reset = %" PRId32 "\n", _Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset ); (*print)( context, "Total Units = %" PRId32 "\n", total_units ); #endif } 1078ea: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1078ed: 5b pop %ebx <== NOT EXECUTED 1078ee: 5e pop %esi <== NOT EXECUTED 1078ef: 5f pop %edi <== NOT EXECUTED 1078f0: c9 leave <== NOT EXECUTED 1078f1: c3 ret <== NOT EXECUTED 00107928 : /* * rtems_cpu_usage_reset */ void rtems_cpu_usage_reset( void ) { 107928: 55 push %ebp <== NOT EXECUTED 107929: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10792b: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _TOD_Get_uptime( &CPU_usage_Uptime_at_last_reset ); 10792e: 68 ec bd 12 00 push $0x12bdec <== NOT EXECUTED 107933: e8 64 4c 00 00 call 10c59c <_TOD_Get_uptime> <== NOT EXECUTED _Thread_Time_of_last_context_switch = CPU_usage_Uptime_at_last_reset; 107938: a1 ec bd 12 00 mov 0x12bdec,%eax <== NOT EXECUTED 10793d: 8b 15 f0 bd 12 00 mov 0x12bdf0,%edx <== NOT EXECUTED 107943: a3 a4 b8 12 00 mov %eax,0x12b8a4 <== NOT EXECUTED 107948: 89 15 a8 b8 12 00 mov %edx,0x12b8a8 <== NOT EXECUTED #else CPU_usage_Ticks_at_last_reset = _Watchdog_Ticks_since_boot; #endif rtems_iterate_over_all_threads(CPU_usage_Per_thread_handler); 10794e: c7 04 24 0c 79 10 00 movl $0x10790c,(%esp) <== NOT EXECUTED 107955: e8 26 50 00 00 call 10c980 <== NOT EXECUTED 10795a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10795d: c9 leave <== NOT EXECUTED 10795e: c3 ret <== NOT EXECUTED 0010f654 : */ void rtems_debug_disable ( rtems_debug_control to_be_disabled ) { 10f654: 55 push %ebp <== NOT EXECUTED 10f655: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f657: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED _Debug_Level &= ~to_be_disabled; 10f65a: f7 d0 not %eax <== NOT EXECUTED 10f65c: 21 05 80 f8 11 00 and %eax,0x11f880 <== NOT EXECUTED } 10f662: c9 leave <== NOT EXECUTED 10f663: c3 ret <== NOT EXECUTED 0010f644 : */ void rtems_debug_enable ( rtems_debug_control to_be_enabled ) { 10f644: 55 push %ebp <== NOT EXECUTED 10f645: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Debug_Level |= to_be_enabled; 10f647: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10f64a: 09 05 80 f8 11 00 or %eax,0x11f880 <== NOT EXECUTED } 10f650: c9 leave <== NOT EXECUTED 10f651: c3 ret <== NOT EXECUTED 0011000c : { 0, 0, 0 }, }; static int rtems_deviceio_errno(rtems_status_code code) { 11000c: 55 push %ebp <== NOT EXECUTED 11000d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11000f: 53 push %ebx <== NOT EXECUTED 110010: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED int rc; if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t) code))) 110013: 50 push %eax <== NOT EXECUTED 110014: 68 e0 97 11 00 push $0x1197e0 <== NOT EXECUTED 110019: e8 06 04 00 00 call 110424 <== NOT EXECUTED 11001e: 89 c3 mov %eax,%ebx <== NOT EXECUTED 110020: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110023: 85 c0 test %eax,%eax <== NOT EXECUTED 110025: 74 07 je 11002e <== NOT EXECUTED { errno = rc; 110027: e8 54 0c 00 00 call 110c80 <__errno> <== NOT EXECUTED 11002c: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return -1; } return -1; } 11002e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 110033: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110036: c9 leave <== NOT EXECUTED 110037: c3 ret <== NOT EXECUTED 0010b890 : int rtems_error( int error_flag, const char *printf_format, ... ) { 10b890: 55 push %ebp <== NOT EXECUTED 10b891: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b893: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b896: 8d 4d 10 lea 0x10(%ebp),%ecx <== NOT EXECUTED va_list arglist; int chars_written; va_start(arglist, printf_format); chars_written = rtems_verror(error_flag, printf_format, arglist); 10b899: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10b89c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b89f: e8 2c fe ff ff call 10b6d0 <== NOT EXECUTED va_end(arglist); return chars_written; } 10b8a4: c9 leave <== NOT EXECUTED 10b8a5: c3 ret <== NOT EXECUTED 00109cf4 : rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 109cf4: 55 push %ebp <== NOT EXECUTED 109cf5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109cf7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109cfa: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 109cfd: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED RTEMS_API_Control *api; if ( !event_out ) 109d00: 85 d2 test %edx,%edx <== NOT EXECUTED 109d02: 74 44 je 109d48 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; 109d04: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED 109d09: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED if ( _Event_sets_Is_empty( event_in ) ) { 109d0f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 109d11: 75 09 jne 109d1c <== NOT EXECUTED *event_out = api->pending_events; 109d13: 8b 00 mov (%eax),%eax <== NOT EXECUTED 109d15: 89 02 mov %eax,(%edx) <== NOT EXECUTED 109d17: 31 c0 xor %eax,%eax <== NOT EXECUTED _Thread_Disable_dispatch(); _Event_Seize( event_in, option_set, ticks, event_out ); _Thread_Enable_dispatch(); return( _Thread_Executing->Wait.return_code ); } 109d19: c9 leave <== NOT EXECUTED 109d1a: c3 ret <== NOT EXECUTED 109d1b: 90 nop <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109d1c: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 109d21: 40 inc %eax <== NOT EXECUTED 109d22: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED *event_out = api->pending_events; return RTEMS_SUCCESSFUL; } _Thread_Disable_dispatch(); _Event_Seize( event_in, option_set, ticks, event_out ); 109d27: 52 push %edx <== NOT EXECUTED 109d28: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 109d2b: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 109d2e: 51 push %ecx <== NOT EXECUTED 109d2f: e8 1c 00 00 00 call 109d50 <_Event_Seize> <== NOT EXECUTED _Thread_Enable_dispatch(); 109d34: e8 13 26 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED return( _Thread_Executing->Wait.return_code ); 109d39: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED 109d3e: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED 109d41: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 109d44: c9 leave <== NOT EXECUTED 109d45: c3 ret <== NOT EXECUTED 109d46: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_event_set *event_out ) { RTEMS_API_Control *api; if ( !event_out ) 109d48: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED _Thread_Disable_dispatch(); _Event_Seize( event_in, option_set, ticks, event_out ); _Thread_Enable_dispatch(); return( _Thread_Executing->Wait.return_code ); } 109d4d: c9 leave <== NOT EXECUTED 109d4e: c3 ret <== NOT EXECUTED 00109e88 : rtems_status_code rtems_event_send( Objects_Id id, rtems_event_set event_in ) { 109e88: 55 push %ebp <== NOT EXECUTED 109e89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109e8b: 53 push %ebx <== NOT EXECUTED 109e8c: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; the_thread = _Thread_Get( id, &location ); 109e8f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109e92: 50 push %eax <== NOT EXECUTED 109e93: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109e96: e8 d5 24 00 00 call 10c370 <_Thread_Get> <== NOT EXECUTED 109e9b: 89 c1 mov %eax,%ecx <== NOT EXECUTED switch ( location ) { 109e9d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ea0: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 109ea3: 85 c0 test %eax,%eax <== NOT EXECUTED 109ea5: 75 29 jne 109ed0 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 109ea7: 8b 81 f4 00 00 00 mov 0xf4(%ecx),%eax <== NOT EXECUTED * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, 109ead: 9c pushf <== NOT EXECUTED 109eae: fa cli <== NOT EXECUTED 109eaf: 5a pop %edx <== NOT EXECUTED void *starting_address, 109eb0: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 109eb3: 09 18 or %ebx,(%eax) <== NOT EXECUTED size_t size, 109eb5: 52 push %edx <== NOT EXECUTED 109eb6: 9d popf <== NOT EXECUTED _Event_sets_Post( event_in, &api->pending_events ); _Event_Surrender( the_thread ); 109eb7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109eba: 51 push %ecx <== NOT EXECUTED 109ebb: e8 1c 00 00 00 call 109edc <_Event_Surrender> <== NOT EXECUTED _Thread_Enable_dispatch(); 109ec0: e8 87 24 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED 109ec5: 31 c0 xor %eax,%eax <== NOT EXECUTED 109ec7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 109eca: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109ecd: c9 leave <== NOT EXECUTED 109ece: c3 ret <== NOT EXECUTED 109ecf: 90 nop <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; the_thread = _Thread_Get( id, &location ); switch ( location ) { 109ed0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 109ed5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109ed8: c9 leave <== NOT EXECUTED 109ed9: c3 ret <== NOT EXECUTED 0010f738 : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 10f738: 55 push %ebp <== NOT EXECUTED 10f739: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f73b: 57 push %edi <== NOT EXECUTED 10f73c: 56 push %esi <== NOT EXECUTED 10f73d: 53 push %ebx <== NOT EXECUTED 10f73e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f741: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10f744: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Extension_Control *the_extension; if ( !id ) 10f747: 85 f6 test %esi,%esi <== NOT EXECUTED 10f749: 74 75 je 10f7c0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10f74b: 85 ff test %edi,%edi <== NOT EXECUTED 10f74d: 75 0d jne 10f75c <== NOT EXECUTED 10f74f: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED ); *id = the_extension->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10f754: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f757: 5b pop %ebx <== NOT EXECUTED 10f758: 5e pop %esi <== NOT EXECUTED 10f759: 5f pop %edi <== NOT EXECUTED 10f75a: c9 leave <== NOT EXECUTED 10f75b: c3 ret <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10f75c: a1 b8 dc 12 00 mov 0x12dcb8,%eax <== NOT EXECUTED 10f761: 40 inc %eax <== NOT EXECUTED 10f762: a3 b8 dc 12 00 mov %eax,0x12dcb8 <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 10f767: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f76a: 68 40 df 12 00 push $0x12df40 <== NOT EXECUTED 10f76f: e8 ac 0c 00 00 call 110420 <_Objects_Allocate> <== NOT EXECUTED 10f774: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 10f776: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f779: 85 c0 test %eax,%eax <== NOT EXECUTED 10f77b: 74 37 je 10f7b4 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 10f77d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f780: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10f783: 8d 40 10 lea 0x10(%eax),%eax <== NOT EXECUTED 10f786: 50 push %eax <== NOT EXECUTED 10f787: e8 9c 26 00 00 call 111e28 <_User_extensions_Add_set> <== NOT EXECUTED 10f78c: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10f78f: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10f792: a1 5c df 12 00 mov 0x12df5c,%eax <== NOT EXECUTED 10f797: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10f79a: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 10f79d: 89 0e mov %ecx,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10f79f: e8 b4 19 00 00 call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 10f7a4: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f7a6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10f7a9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f7ac: 5b pop %ebx <== NOT EXECUTED 10f7ad: 5e pop %esi <== NOT EXECUTED 10f7ae: 5f pop %edi <== NOT EXECUTED 10f7af: c9 leave <== NOT EXECUTED 10f7b0: c3 ret <== NOT EXECUTED 10f7b1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { _Thread_Enable_dispatch(); 10f7b4: e8 9f 19 00 00 call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 10f7b9: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10f7be: eb 94 jmp 10f754 <== NOT EXECUTED Objects_Id *id ) { Extension_Control *the_extension; if ( !id ) 10f7c0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10f7c5: eb 8d jmp 10f754 <== NOT EXECUTED 0010f7c8 : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 10f7c8: 55 push %ebp <== NOT EXECUTED 10f7c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f7cb: 53 push %ebx <== NOT EXECUTED 10f7cc: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure 10f7cf: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10f7d2: 50 push %eax <== NOT EXECUTED 10f7d3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f7d6: 68 40 df 12 00 push $0x12df40 <== NOT EXECUTED 10f7db: e8 34 11 00 00 call 110914 <_Objects_Get> <== NOT EXECUTED 10f7e0: 89 c3 mov %eax,%ebx <== NOT EXECUTED Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 10f7e2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f7e5: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10f7e8: 85 c0 test %eax,%eax <== NOT EXECUTED 10f7ea: 75 38 jne 10f824 <== NOT EXECUTED case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 10f7ec: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f7ef: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10f7f2: 50 push %eax <== NOT EXECUTED 10f7f3: e8 30 27 00 00 call 111f28 <_User_extensions_Remove_set> <== NOT EXECUTED _Objects_Close( &_Extension_Information, &the_extension->Object ); 10f7f8: 59 pop %ecx <== NOT EXECUTED 10f7f9: 58 pop %eax <== NOT EXECUTED 10f7fa: 53 push %ebx <== NOT EXECUTED 10f7fb: 68 40 df 12 00 push $0x12df40 <== NOT EXECUTED 10f800: e8 9b 0c 00 00 call 1104a0 <_Objects_Close> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 10f805: 58 pop %eax <== NOT EXECUTED 10f806: 5a pop %edx <== NOT EXECUTED 10f807: 53 push %ebx <== NOT EXECUTED 10f808: 68 40 df 12 00 push $0x12df40 <== NOT EXECUTED 10f80d: e8 ce 0f 00 00 call 1107e0 <_Objects_Free> <== NOT EXECUTED _Extension_Free( the_extension ); _Thread_Enable_dispatch(); 10f812: e8 41 19 00 00 call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 10f817: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f819: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f81c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f81f: c9 leave <== NOT EXECUTED 10f820: c3 ret <== NOT EXECUTED 10f821: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 10f824: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f829: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f82c: c9 leave <== NOT EXECUTED 10f82d: c3 ret <== NOT EXECUTED 0010c454 : rtems_status_code rtems_extension_ident( rtems_name name, Objects_Id *id ) { 10c454: 55 push %ebp <== NOT EXECUTED 10c455: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c457: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 10c45a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c45d: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 10c462: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c465: 68 a0 4d 12 00 push $0x124da0 <== NOT EXECUTED 10c46a: e8 45 12 00 00 call 10d6b4 <_Objects_Name_to_id_u32> <== NOT EXECUTED 10c46f: 8b 04 85 94 d6 11 00 mov 0x11d694(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 10c476: c9 leave <== NOT EXECUTED 10c477: c3 ret <== NOT EXECUTED 0010aa48 : */ void rtems_fatal_error_occurred( uint32_t the_error ) { 10aa48: 55 push %ebp <== NOT EXECUTED 10aa49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa4b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, FALSE, the_error ); 10aa4e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10aa51: 6a 00 push $0x0 <== NOT EXECUTED 10aa53: 6a 01 push $0x1 <== NOT EXECUTED 10aa55: e8 26 0b 00 00 call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 00106ec4 : int rtems_filesystem_evaluate_parent( int flags, rtems_filesystem_location_info_t *pathloc ) { 106ec4: 55 push %ebp <== NOT EXECUTED 106ec5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106ec7: 57 push %edi <== NOT EXECUTED 106ec8: 56 push %esi <== NOT EXECUTED 106ec9: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 106ecc: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED rtems_filesystem_location_info_t parent; int result; if ( !pathloc ) 106ecf: 85 f6 test %esi,%esi <== NOT EXECUTED 106ed1: 74 76 je 106f49 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */ if ( !pathloc->ops->evalpath_h ) 106ed3: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 106ed6: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 106ed8: 85 c9 test %ecx,%ecx <== NOT EXECUTED 106eda: 74 54 je 106f30 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); parent = *pathloc; 106edc: 8d 7d e8 lea -0x18(%ebp),%edi <== NOT EXECUTED 106edf: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 106ee4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED result = (*pathloc->ops->evalpath_h)( "..", flags, &parent ); 106ee6: 52 push %edx <== NOT EXECUTED 106ee7: 8d 7d e8 lea -0x18(%ebp),%edi <== NOT EXECUTED 106eea: 57 push %edi <== NOT EXECUTED 106eeb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106eee: 68 b3 8e 11 00 push $0x118eb3 <== NOT EXECUTED 106ef3: ff 10 call *(%eax) <== NOT EXECUTED 106ef5: 89 c6 mov %eax,%esi <== NOT EXECUTED if (result != 0){ 106ef7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106efa: 85 c0 test %eax,%eax <== NOT EXECUTED 106efc: 75 22 jne 106f20 <== NOT EXECUTED return -1; } rtems_filesystem_freenode( &parent ); 106efe: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 106f01: 85 c0 test %eax,%eax <== NOT EXECUTED 106f03: 74 10 je 106f15 <== NOT EXECUTED 106f05: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 106f08: 85 c0 test %eax,%eax <== NOT EXECUTED 106f0a: 74 09 je 106f15 <== NOT EXECUTED 106f0c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106f0f: 57 push %edi <== NOT EXECUTED 106f10: ff d0 call *%eax <== NOT EXECUTED 106f12: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 106f15: 89 f0 mov %esi,%eax <== NOT EXECUTED 106f17: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 106f1a: 5e pop %esi <== NOT EXECUTED 106f1b: 5f pop %edi <== NOT EXECUTED 106f1c: c9 leave <== NOT EXECUTED 106f1d: c3 ret <== NOT EXECUTED 106f1e: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !pathloc->ops->evalpath_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); parent = *pathloc; result = (*pathloc->ops->evalpath_h)( "..", flags, &parent ); if (result != 0){ 106f20: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED return -1; } rtems_filesystem_freenode( &parent ); return result; } 106f25: 89 f0 mov %esi,%eax <== NOT EXECUTED 106f27: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 106f2a: 5e pop %esi <== NOT EXECUTED 106f2b: 5f pop %edi <== NOT EXECUTED 106f2c: c9 leave <== NOT EXECUTED 106f2d: c3 ret <== NOT EXECUTED 106f2e: 66 90 xchg %ax,%ax <== 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 ); 106f30: e8 4b 9d 00 00 call 110c80 <__errno> <== NOT EXECUTED 106f35: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 106f3b: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED return -1; } rtems_filesystem_freenode( &parent ); return result; } 106f40: 89 f0 mov %esi,%eax <== NOT EXECUTED 106f42: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 106f45: 5e pop %esi <== NOT EXECUTED 106f46: 5f pop %edi <== NOT EXECUTED 106f47: c9 leave <== NOT EXECUTED 106f48: c3 ret <== NOT EXECUTED { rtems_filesystem_location_info_t parent; int result; if ( !pathloc ) rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */ 106f49: e8 32 9d 00 00 call 110c80 <__errno> <== NOT EXECUTED 106f4e: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 106f54: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 106f59: eb ba jmp 106f15 <== NOT EXECUTED 00106f5c : const char *pathname, int flags, rtems_filesystem_location_info_t *pathloc, int follow_link ) { 106f5c: 55 push %ebp <== NOT EXECUTED 106f5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106f5f: 57 push %edi <== NOT EXECUTED 106f60: 56 push %esi <== NOT EXECUTED 106f61: 53 push %ebx <== NOT EXECUTED 106f62: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 106f65: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 106f68: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 106f6b: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 106f6e: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 106f71: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED 106f74: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 106f77: 89 7d ec mov %edi,-0x14(%ebp) <== NOT EXECUTED /* * Verify Input parameters. */ if ( !pathname ) 106f7a: 85 db test %ebx,%ebx <== NOT EXECUTED 106f7c: 0f 84 08 01 00 00 je 10708a <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); if ( !pathloc ) 106f82: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED 106f85: 85 ff test %edi,%edi <== NOT EXECUTED 106f87: 0f 84 eb 00 00 00 je 107078 <== NOT EXECUTED /* * Evaluate the path using the optable evalpath. */ rtems_filesystem_get_start_loc( pathname, &i, pathloc ); 106f8d: 8a 03 mov (%ebx),%al <== NOT EXECUTED 106f8f: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 106f91: 74 1d je 106fb0 <== NOT EXECUTED 106f93: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 106f95: 74 19 je 106fb0 <== NOT EXECUTED 106f97: 84 c0 test %al,%al <== NOT EXECUTED 106f99: 74 15 je 106fb0 <== NOT EXECUTED 106f9b: a1 74 d5 11 00 mov 0x11d574,%eax <== NOT EXECUTED 106fa0: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 106fa3: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 106fa8: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED 106fab: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 106fad: eb 15 jmp 106fc4 <== NOT EXECUTED 106faf: 90 nop <== NOT EXECUTED 106fb0: a1 74 d5 11 00 mov 0x11d574,%eax <== NOT EXECUTED 106fb5: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 106fb8: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 106fbd: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED 106fc0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 106fc2: b1 01 mov $0x1,%cl <== NOT EXECUTED if ( !pathloc->ops->evalpath_h ) 106fc4: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 106fc7: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 106fca: 8b 10 mov (%eax),%edx <== NOT EXECUTED 106fcc: 85 d2 test %edx,%edx <== NOT EXECUTED 106fce: 0f 84 80 00 00 00 je 107054 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); result = (*pathloc->ops->evalpath_h)( &pathname[i], flags, pathloc ); 106fd4: 56 push %esi <== NOT EXECUTED 106fd5: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 106fd8: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 106fdb: 8d 04 0b lea (%ebx,%ecx,1),%eax <== NOT EXECUTED 106fde: 50 push %eax <== NOT EXECUTED 106fdf: ff d2 call *%edx <== NOT EXECUTED 106fe1: 89 c6 mov %eax,%esi <== NOT EXECUTED /* * Get the Node type and determine if you need to follow the link or * not. */ if ( (result == 0) && follow_link ) { 106fe3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106fe6: 85 c0 test %eax,%eax <== NOT EXECUTED 106fe8: 75 2a jne 107014 <== NOT EXECUTED 106fea: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 106fed: 85 db test %ebx,%ebx <== NOT EXECUTED 106fef: 74 23 je 107014 <== NOT EXECUTED if ( !pathloc->ops->node_type_h ){ 106ff1: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED 106ff4: 8b 57 08 mov 0x8(%edi),%edx <== NOT EXECUTED 106ff7: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 106ffa: 85 c0 test %eax,%eax <== NOT EXECUTED 106ffc: 74 68 je 107066 <== NOT EXECUTED rtems_filesystem_freenode( pathloc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } type = (*pathloc->ops->node_type_h)( pathloc ); 106ffe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107001: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 107004: ff d0 call *%eax <== NOT EXECUTED if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) || 107006: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED 107009: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10700c: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10700f: 76 0f jbe 107020 <== NOT EXECUTED 107011: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } } return result; } 107014: 89 f0 mov %esi,%eax <== NOT EXECUTED 107016: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107019: 5b pop %ebx <== NOT EXECUTED 10701a: 5e pop %esi <== NOT EXECUTED 10701b: 5f pop %edi <== NOT EXECUTED 10701c: c9 leave <== NOT EXECUTED 10701d: c3 ret <== NOT EXECUTED 10701e: 66 90 xchg %ax,%ax <== NOT EXECUTED type = (*pathloc->ops->node_type_h)( pathloc ); if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) || ( type == RTEMS_FILESYSTEM_SYM_LINK ) ) { if ( !pathloc->ops->eval_link_h ){ 107020: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 107023: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 107026: 8b 48 34 mov 0x34(%eax),%ecx <== NOT EXECUTED 107029: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10702b: 74 15 je 107042 <== NOT EXECUTED * pathloc will be passed up (and eventually released). * Hence, the (valid) originial node that we submit to * eval_link_h() should be released by the handler. */ result = (*pathloc->ops->eval_link_h)( pathloc, flags ); 10702d: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 107030: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 107033: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 107036: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } } return result; } 107039: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10703c: 5b pop %ebx <== NOT EXECUTED 10703d: 5e pop %esi <== NOT EXECUTED 10703e: 5f pop %edi <== NOT EXECUTED 10703f: c9 leave <== NOT EXECUTED * pathloc will be passed up (and eventually released). * Hence, the (valid) originial node that we submit to * eval_link_h() should be released by the handler. */ result = (*pathloc->ops->eval_link_h)( pathloc, flags ); 107040: ff e1 jmp *%ecx <== NOT EXECUTED if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) || ( type == RTEMS_FILESYSTEM_SYM_LINK ) ) { if ( !pathloc->ops->eval_link_h ){ rtems_filesystem_freenode( pathloc ); 107042: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 107045: 85 c0 test %eax,%eax <== NOT EXECUTED 107047: 74 0b je 107054 <== NOT EXECUTED 107049: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10704c: 52 push %edx <== NOT EXECUTED 10704d: ff d0 call *%eax <== NOT EXECUTED 10704f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107052: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 107054: e8 27 9c 00 00 call 110c80 <__errno> <== NOT EXECUTED 107059: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10705f: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 107064: eb ae jmp 107014 <== NOT EXECUTED */ if ( (result == 0) && follow_link ) { if ( !pathloc->ops->node_type_h ){ rtems_filesystem_freenode( pathloc ); 107066: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 107069: 85 c0 test %eax,%eax <== NOT EXECUTED 10706b: 74 e7 je 107054 <== NOT EXECUTED 10706d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107070: 57 push %edi <== NOT EXECUTED 107071: ff d0 call *%eax <== NOT EXECUTED 107073: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107076: eb dc jmp 107054 <== NOT EXECUTED if ( !pathname ) rtems_set_errno_and_return_minus_one( EFAULT ); if ( !pathloc ) rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */ 107078: e8 03 9c 00 00 call 110c80 <__errno> <== NOT EXECUTED 10707d: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 107083: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 107088: eb 8a jmp 107014 <== NOT EXECUTED /* * Verify Input parameters. */ if ( !pathname ) rtems_set_errno_and_return_minus_one( EFAULT ); 10708a: e8 f1 9b 00 00 call 110c80 <__errno> <== NOT EXECUTED 10708f: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 107095: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 10709a: e9 75 ff ff ff jmp 107014 <== NOT EXECUTED 0010e400 : * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) { 10e400: 55 push %ebp <== NOT EXECUTED 10e401: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e403: 57 push %edi <== NOT EXECUTED 10e404: 56 push %esi <== NOT EXECUTED 10e405: 53 push %ebx <== NOT EXECUTED 10e406: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED /* * Set the default umask to "022". */ rtems_filesystem_umask = 022; 10e409: a1 74 d5 11 00 mov 0x11d574,%eax <== NOT EXECUTED 10e40e: c7 40 24 12 00 00 00 movl $0x12,0x24(%eax) <== NOT EXECUTED init_fs_mount_table(); 10e415: e8 7a 05 00 00 call 10e994 <== NOT EXECUTED /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) 10e41a: a1 cc 79 11 00 mov 0x1179cc,%eax <== NOT EXECUTED 10e41f: 85 c0 test %eax,%eax <== NOT EXECUTED 10e421: 0f 84 a5 00 00 00 je 10e4cc <== NOT EXECUTED rtems_fatal_error_occurred( 0xABCD0001 ); mt = &rtems_filesystem_mount_table[0]; 10e427: a1 08 b1 11 00 mov 0x11b108,%eax <== NOT EXECUTED status = mount( 10e42c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e42f: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10e432: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10e435: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED 10e438: ff 30 pushl (%eax) <== NOT EXECUTED 10e43a: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10e43d: 50 push %eax <== NOT EXECUTED 10e43e: e8 79 05 00 00 call 10e9bc <== NOT EXECUTED &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point ); if ( status == -1 ) 10e443: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10e446: 40 inc %eax <== NOT EXECUTED 10e447: 0f 84 8c 00 00 00 je 10e4d9 <== NOT EXECUTED rtems_fatal_error_occurred( 0xABCD0002 ); rtems_filesystem_link_counts = 0; 10e44d: a1 74 d5 11 00 mov 0x11d574,%eax <== NOT EXECUTED 10e452: 66 c7 40 28 00 00 movw $0x0,0x28(%eax) <== NOT EXECUTED * set_private_env() - but then: that's * gonna hit performance. * * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; 10e458: 8d 78 14 lea 0x14(%eax),%edi <== NOT EXECUTED 10e45b: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10e45e: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 10e461: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10e466: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 10e468: 6a 00 push $0x0 <== NOT EXECUTED 10e46a: 8d 5d e0 lea -0x20(%ebp),%ebx <== NOT EXECUTED 10e46d: 53 push %ebx <== NOT EXECUTED 10e46e: 6a 00 push $0x0 <== NOT EXECUTED 10e470: 68 d8 94 11 00 push $0x1194d8 <== NOT EXECUTED 10e475: e8 e2 8a ff ff call 106f5c <== NOT EXECUTED rtems_filesystem_root = loc; 10e47a: a1 74 d5 11 00 mov 0x11d574,%eax <== NOT EXECUTED 10e47f: 8d 78 14 lea 0x14(%eax),%edi <== NOT EXECUTED 10e482: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10e487: 89 de mov %ebx,%esi <== NOT EXECUTED 10e489: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 10e48b: 6a 00 push $0x0 <== NOT EXECUTED 10e48d: 53 push %ebx <== NOT EXECUTED 10e48e: 6a 00 push $0x0 <== NOT EXECUTED 10e490: 68 d8 94 11 00 push $0x1194d8 <== NOT EXECUTED 10e495: e8 c2 8a ff ff call 106f5c <== NOT EXECUTED rtems_filesystem_current = loc; 10e49a: a1 74 d5 11 00 mov 0x11d574,%eax <== NOT EXECUTED 10e49f: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 10e4a2: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10e4a7: 89 de mov %ebx,%esi <== NOT EXECUTED 10e4a9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED * * 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); 10e4ab: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10e4ae: 68 ff 01 00 00 push $0x1ff <== NOT EXECUTED 10e4b3: 68 da 94 11 00 push $0x1194da <== NOT EXECUTED 10e4b8: e8 bb 04 00 00 call 10e978 <== NOT EXECUTED if ( status != 0 ) 10e4bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e4c0: 85 c0 test %eax,%eax <== NOT EXECUTED 10e4c2: 75 22 jne 10e4e6 <== NOT EXECUTED * before device drivers are initialized. So we return via a base * filesystem image and nothing auto-mounted at this point. */ #endif } 10e4c4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e4c7: 5b pop %ebx <== NOT EXECUTED 10e4c8: 5e pop %esi <== NOT EXECUTED 10e4c9: 5f pop %edi <== NOT EXECUTED 10e4ca: c9 leave <== NOT EXECUTED 10e4cb: c3 ret <== NOT EXECUTED /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) rtems_fatal_error_occurred( 0xABCD0001 ); 10e4cc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e4cf: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED 10e4d4: e8 6f c5 ff ff call 10aa48 <== NOT EXECUTED status = mount( &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point ); if ( status == -1 ) rtems_fatal_error_occurred( 0xABCD0002 ); 10e4d9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e4dc: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED 10e4e1: e8 62 c5 ff ff call 10aa48 <== NOT EXECUTED * created that way by the IMFS. */ status = mkdir( "/dev", 0777); if ( status != 0 ) rtems_fatal_error_occurred( 0xABCD0003 ); 10e4e6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e4e9: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED 10e4ee: e8 55 c5 ff ff call 10aa48 <== NOT EXECUTED 00125614 : ); bool rtems_filesystem_nodes_equal( const rtems_filesystem_location_info_t *loc1, const rtems_filesystem_location_info_t *loc2 ){ 125614: 55 push %ebp <== NOT EXECUTED 125615: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125617: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 12561a: 8b 10 mov (%eax),%edx <== NOT EXECUTED 12561c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 12561f: 3b 10 cmp (%eax),%edx <== NOT EXECUTED 125621: 0f 94 c0 sete %al <== NOT EXECUTED return ( loc1->node_access == loc2->node_access ); } 125624: c9 leave <== NOT EXECUTED 125625: c3 ret <== NOT EXECUTED 0010c208 : #endif #include const char *rtems_get_version_string(void) { 10c208: 55 push %ebp <== NOT EXECUTED 10c209: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _RTEMS_version; } 10c20b: b8 80 f0 11 00 mov $0x11f080,%eax <== NOT EXECUTED 10c210: c9 leave <== NOT EXECUTED 10c211: c3 ret <== NOT EXECUTED 0010a900 : * Scheduling can properly occur now as long as we avoid dispatching. */ } void rtems_initialize_before_drivers(void) { 10a900: 55 push %ebp <== NOT EXECUTED 10a901: 89 e5 mov %esp,%ebp <== NOT EXECUTED * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); } 10a903: c9 leave <== NOT EXECUTED /* * Run the API and BSPs predriver hook. */ _API_extensions_Run_predriver(); 10a904: e9 4f 03 00 00 jmp 10ac58 <_API_extensions_Run_predriver> <== NOT EXECUTED 0010a90c : Objects_Information *_Internal_Objects[ OBJECTS_INTERNAL_CLASSES_LAST + 1 ]; void rtems_initialize_data_structures( rtems_configuration_table *configuration_table ) { 10a90c: 55 push %ebp <== NOT EXECUTED 10a90d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a90f: 53 push %ebx <== NOT EXECUTED 10a910: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a913: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* * 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 ); 10a916: 9c pushf <== NOT EXECUTED 10a917: fa cli <== NOT EXECUTED 10a918: 58 pop %eax <== NOT EXECUTED /* * Make sure the parameters were not NULL. */ if ( configuration_table == NULL ) 10a919: 85 db test %ebx,%ebx <== NOT EXECUTED 10a91b: 0f 84 f4 00 00 00 je 10aa15 <== NOT EXECUTED ); /* * Provide pointers just for later convenience. */ _Configuration_Table = configuration_table; 10a921: 89 1d 54 f8 11 00 mov %ebx,0x11f854 <== NOT EXECUTED /* * Initialize any target architecture specific support as early as possible */ _CPU_Initialize( _Thread_Dispatch ); 10a927: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a92a: 68 f0 c1 10 00 push $0x10c1f0 <== NOT EXECUTED 10a92f: e8 ac 2d 00 00 call 10d6e0 <_CPU_Initialize> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 10a934: c7 05 84 f9 11 00 00 movl $0x0,0x11f984 <== NOT EXECUTED 10a93b: 00 00 00 <== NOT EXECUTED /* * Do this as early as possible to insure no debugging output * is even attempted to be printed. */ _Debug_Manager_initialization(); 10a93e: e8 f1 4c 00 00 call 10f634 <_Debug_Manager_initialization> <== NOT EXECUTED _API_extensions_Initialization(); 10a943: e8 ec 02 00 00 call 10ac34 <_API_extensions_Initialization> <== NOT EXECUTED 10a948: c7 05 b8 f7 11 00 01 movl $0x1,0x11f7b8 <== NOT EXECUTED 10a94f: 00 00 00 <== NOT EXECUTED /* * Before this is called, we are not allowed to allocate memory * from the Workspace because it is not initialized. */ _Workspace_Handler_initialization( 10a952: 59 pop %ecx <== NOT EXECUTED 10a953: 58 pop %eax <== NOT EXECUTED 10a954: ff 73 04 pushl 0x4(%ebx) <== NOT EXECUTED 10a957: ff 33 pushl (%ebx) <== NOT EXECUTED 10a959: e8 62 2b 00 00 call 10d4c0 <_Workspace_Handler_initialization> <== NOT EXECUTED (void *)configuration_table->work_space_start, configuration_table->work_space_size ); _User_extensions_Handler_initialization( 10a95e: 58 pop %eax <== NOT EXECUTED 10a95f: 5a pop %edx <== NOT EXECUTED 10a960: ff 73 3c pushl 0x3c(%ebx) <== NOT EXECUTED 10a963: ff 73 38 pushl 0x38(%ebx) <== NOT EXECUTED 10a966: e8 85 26 00 00 call 10cff0 <_User_extensions_Handler_initialization> <== NOT EXECUTED configuration_table->number_of_initial_extensions, configuration_table->User_extension_table ); _ISR_Handler_initialization(); 10a96b: e8 50 0c 00 00 call 10b5c0 <_ISR_Handler_initialization> <== NOT EXECUTED _Objects_Handler_initialization( 10a970: e8 6f 13 00 00 call 10bce4 <_Objects_Handler_initialization> <== NOT EXECUTED _Configuration_MP_table->maximum_nodes, _Configuration_MP_table->maximum_global_objects #endif ); _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects; 10a975: c7 05 90 f7 11 00 d0 movl $0x11f7d0,0x11f790 <== NOT EXECUTED 10a97c: f7 11 00 <== NOT EXECUTED /* * Initialize the internal allocator Mutex */ _API_Mutex_Initialization( 1 ); 10a97f: c7 04 24 01 00 00 00 movl $0x1,(%esp) <== NOT EXECUTED 10a986: e8 01 04 00 00 call 10ad8c <_API_Mutex_Initialization> <== NOT EXECUTED _API_Mutex_Allocate( &_RTEMS_Allocator_Mutex ); 10a98b: c7 04 24 74 f8 11 00 movl $0x11f874,(%esp) <== NOT EXECUTED 10a992: e8 75 03 00 00 call 10ad0c <_API_Mutex_Allocate> <== NOT EXECUTED #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of 10a997: 66 c7 05 70 f8 11 00 movw $0x0,0x11f870 <== NOT EXECUTED 10a99e: 00 00 <== NOT EXECUTED 10a9a0: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a9a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a9a5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 10a9a8: 66 c7 84 00 00 f9 11 movw $0x0,0x11f900(%eax,%eax,1) <== NOT EXECUTED 10a9af: 00 00 00 <== NOT EXECUTED /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of 10a9b2: 40 inc %eax <== NOT EXECUTED 10a9b3: 83 f8 10 cmp $0x10,%eax <== NOT EXECUTED 10a9b6: 75 f0 jne 10a9a8 <== NOT EXECUTED _Priority_Handler_initialization(); _Watchdog_Handler_initialization(); 10a9b8: e8 6f 29 00 00 call 10d32c <_Watchdog_Handler_initialization> <== NOT EXECUTED _TOD_Handler_initialization( configuration_table->microseconds_per_tick ); 10a9bd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a9c0: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10a9c3: e8 28 09 00 00 call 10b2f0 <_TOD_Handler_initialization> <== NOT EXECUTED _Thread_Handler_initialization( 10a9c8: 5a pop %edx <== NOT EXECUTED 10a9c9: 59 pop %ecx <== NOT EXECUTED 10a9ca: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a9cd: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10a9d0: e8 23 1c 00 00 call 10c5f8 <_Thread_Handler_initialization> <== NOT EXECUTED ); #endif /* MANAGERS */ _RTEMS_API_Initialize( configuration_table ); 10a9d5: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a9d8: e8 d3 01 00 00 call 10abb0 <_RTEMS_API_Initialize> <== NOT EXECUTED _Extension_Manager_initialization( configuration_table->maximum_extensions ); 10a9dd: 58 pop %eax <== NOT EXECUTED 10a9de: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a9e1: e8 3e 00 00 00 call 10aa24 <_Extension_Manager_initialization> <== NOT EXECUTED _IO_Manager_initialization( 10a9e6: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10a9e9: ff 73 2c pushl 0x2c(%ebx) <== NOT EXECUTED 10a9ec: ff 73 30 pushl 0x30(%ebx) <== NOT EXECUTED 10a9ef: ff 73 34 pushl 0x34(%ebx) <== NOT EXECUTED 10a9f2: e8 95 00 00 00 call 10aa8c <_IO_Manager_initialization> <== NOT EXECUTED configuration_table->number_of_device_drivers, configuration_table->maximum_drivers ); #ifdef RTEMS_POSIX_API _POSIX_API_Initialize( configuration_table ); 10a9f7: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a9fa: e8 15 01 00 00 call 10ab14 <_POSIX_API_Initialize> <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10a9ff: c7 05 84 f9 11 00 01 movl $0x1,0x11f984 <== NOT EXECUTED 10aa06: 00 00 00 <== NOT EXECUTED * * 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(); 10aa09: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Scheduling can properly occur now as long as we avoid dispatching. */ } 10aa0c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aa0f: c9 leave <== NOT EXECUTED * * 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(); 10aa10: e9 03 17 00 00 jmp 10c118 <_Thread_Create_idle> <== NOT EXECUTED /* * Make sure the parameters were not NULL. */ if ( configuration_table == NULL ) _Internal_error_Occurred( 10aa15: 50 push %eax <== NOT EXECUTED 10aa16: 6a 00 push $0x0 <== NOT EXECUTED 10aa18: 6a 01 push $0x1 <== NOT EXECUTED 10aa1a: 6a 00 push $0x0 <== NOT EXECUTED 10aa1c: e8 5f 0b 00 00 call 10b580 <_Internal_error_Occurred> <== NOT EXECUTED 0010a8ec : _API_extensions_Run_predriver(); } void rtems_initialize_device_drivers(void) { 10a8ec: 55 push %ebp <== NOT EXECUTED 10a8ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a8ef: 83 ec 08 sub $0x8,%esp <== 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(); 10a8f2: e8 65 01 00 00 call 10aa5c <_IO_Initialize_all_drivers> <== NOT EXECUTED * * The API extensions are supposed to create user initialization tasks. */ _API_extensions_Run_postdriver(); } 10a8f7: c9 leave <== NOT EXECUTED * Run the APIs and BSPs postdriver hooks. * * The API extensions are supposed to create user initialization tasks. */ _API_extensions_Run_postdriver(); 10a8f8: e9 8b 03 00 00 jmp 10ac88 <_API_extensions_Run_postdriver> <== NOT EXECUTED 0010a8d8 : _API_extensions_Run_postdriver(); } void rtems_initialize_start_multitasking(void) { 10a8d8: 55 push %ebp <== NOT EXECUTED 10a8d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 10a8db: c7 05 84 f9 11 00 02 movl $0x2,0x11f984 <== NOT EXECUTED 10a8e2: 00 00 00 <== NOT EXECUTED ****** APPLICATION RUNS HERE ****** ****** RETURNS WHEN SYSTEM IS SHUT DOWN ****** ******************************************************************* ******************************************************************* *******************************************************************/ } 10a8e5: c9 leave <== NOT EXECUTED void rtems_initialize_start_multitasking(void) { _System_state_Set( SYSTEM_STATE_BEGIN_MULTITASKING ); _Thread_Start_multitasking(); 10a8e6: e9 01 25 00 00 jmp 10cdec <_Thread_Start_multitasking> <== NOT EXECUTED 0010a708 : rtems_status_code rtems_interrupt_catch( rtems_isr_entry new_isr_handler, rtems_vector_number vector, rtems_isr_entry *old_isr_handler ) { 10a708: 55 push %ebp <== NOT EXECUTED 10a709: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a70b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a70e: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a711: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED if ( !_ISR_Is_vector_number_valid( vector ) ) 10a714: 81 7d 0c ff 00 00 00 cmpl $0xff,0xc(%ebp) <== NOT EXECUTED 10a71b: 77 23 ja 10a740 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( !_ISR_Is_valid_user_handler( (void *) new_isr_handler ) ) 10a71d: 85 d2 test %edx,%edx <== NOT EXECUTED 10a71f: 74 17 je 10a738 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_ISR_Is_valid_user_handler( (void *) old_isr_handler ) ) 10a721: 85 c0 test %eax,%eax <== NOT EXECUTED 10a723: 74 13 je 10a738 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _ISR_Install_vector( 10a725: 51 push %ecx <== NOT EXECUTED 10a726: 50 push %eax <== NOT EXECUTED 10a727: 52 push %edx <== NOT EXECUTED 10a728: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a72b: e8 b4 c5 ff ff call 106ce4 <_CPU_ISR_install_vector> <== NOT EXECUTED 10a730: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a732: 83 c4 10 add $0x10,%esp <== NOT EXECUTED vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler ); return RTEMS_SUCCESSFUL; } 10a735: c9 leave <== NOT EXECUTED 10a736: c3 ret <== NOT EXECUTED 10a737: 90 nop <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _ISR_Install_vector( vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler ); return RTEMS_SUCCESSFUL; 10a738: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } 10a73d: c9 leave <== NOT EXECUTED 10a73e: c3 ret <== NOT EXECUTED 10a73f: 90 nop <== NOT EXECUTED rtems_isr_entry new_isr_handler, rtems_vector_number vector, rtems_isr_entry *old_isr_handler ) { if ( !_ISR_Is_vector_number_valid( vector ) ) 10a740: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED _ISR_Install_vector( vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler ); return RTEMS_SUCCESSFUL; } 10a745: c9 leave <== NOT EXECUTED 10a746: c3 ret <== NOT EXECUTED 0010acac : */ #undef rtems_interrupt_disable rtems_interrupt_level rtems_interrupt_disable( void ) { 10acac: 55 push %ebp <== NOT EXECUTED 10acad: 89 e5 mov %esp,%ebp <== NOT EXECUTED rtems_interrupt_level previous_level; _ISR_Disable( previous_level ); 10acaf: 9c pushf <== NOT EXECUTED 10acb0: fa cli <== NOT EXECUTED 10acb1: 58 pop %eax <== NOT EXECUTED return previous_level; } 10acb2: c9 leave <== NOT EXECUTED 10acb3: c3 ret <== NOT EXECUTED 0010acb4 : #undef rtems_interrupt_enable void rtems_interrupt_enable( rtems_interrupt_level previous_level ) { 10acb4: 55 push %ebp <== NOT EXECUTED 10acb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED _ISR_Enable( previous_level ); 10acb7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10acba: 9d popf <== NOT EXECUTED } 10acbb: c9 leave <== NOT EXECUTED 10acbc: c3 ret <== NOT EXECUTED 0010acc0 : #undef rtems_interrupt_flash void rtems_interrupt_flash( rtems_interrupt_level previous_level ) { 10acc0: 55 push %ebp <== NOT EXECUTED 10acc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED _ISR_Flash( previous_level ); 10acc3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10acc6: 9d popf <== NOT EXECUTED 10acc7: fa cli <== NOT EXECUTED } 10acc8: c9 leave <== NOT EXECUTED 10acc9: c3 ret <== NOT EXECUTED 0010accc : */ #undef rtems_interrupt_is_in_progress bool rtems_interrupt_is_in_progress( void ) { 10accc: 55 push %ebp <== NOT EXECUTED 10accd: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _ISR_Is_in_progress(); 10accf: a1 d8 27 12 00 mov 0x1227d8,%eax <== NOT EXECUTED 10acd4: 85 c0 test %eax,%eax <== NOT EXECUTED 10acd6: 0f 95 c0 setne %al <== NOT EXECUTED } 10acd9: c9 leave <== NOT EXECUTED 10acda: c3 ret <== NOT EXECUTED 001108e4 : rtems_status_code rtems_io_close( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 1108e4: 55 push %ebp <== NOT EXECUTED 1108e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1108e7: 56 push %esi <== NOT EXECUTED 1108e8: 53 push %ebx <== NOT EXECUTED 1108e9: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1108ec: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1108ef: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 1108f2: 39 0d 20 02 12 00 cmp %ecx,0x120220 <== NOT EXECUTED 1108f8: 76 1e jbe 110918 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; 1108fa: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 1108fd: a1 24 02 12 00 mov 0x120224,%eax <== NOT EXECUTED 110902: 8b 44 d0 08 mov 0x8(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 110906: 85 c0 test %eax,%eax <== NOT EXECUTED 110908: 74 13 je 11091d <== NOT EXECUTED 11090a: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 11090d: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 110910: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 110913: 5b pop %ebx <== NOT EXECUTED 110914: 5e pop %esi <== NOT EXECUTED 110915: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 110916: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 110918: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 11091d: 5b pop %ebx <== NOT EXECUTED 11091e: 5e pop %esi <== NOT EXECUTED 11091f: c9 leave <== NOT EXECUTED 110920: c3 ret <== NOT EXECUTED 00110924 : rtems_status_code rtems_io_control( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 110924: 55 push %ebp <== NOT EXECUTED 110925: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110927: 56 push %esi <== NOT EXECUTED 110928: 53 push %ebx <== NOT EXECUTED 110929: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 11092c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11092f: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 110932: 39 0d 20 02 12 00 cmp %ecx,0x120220 <== NOT EXECUTED 110938: 76 1e jbe 110958 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; 11093a: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 11093d: a1 24 02 12 00 mov 0x120224,%eax <== NOT EXECUTED 110942: 8b 44 d0 14 mov 0x14(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 110946: 85 c0 test %eax,%eax <== NOT EXECUTED 110948: 74 13 je 11095d <== NOT EXECUTED 11094a: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 11094d: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 110950: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 110953: 5b pop %ebx <== NOT EXECUTED 110954: 5e pop %esi <== NOT EXECUTED 110955: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 110956: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 110958: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 11095d: 5b pop %ebx <== NOT EXECUTED 11095e: 5e pop %esi <== NOT EXECUTED 11095f: c9 leave <== NOT EXECUTED 110960: c3 ret <== NOT EXECUTED 0010f678 : rtems_status_code rtems_io_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10f678: 55 push %ebp <== NOT EXECUTED 10f679: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f67b: 56 push %esi <== NOT EXECUTED 10f67c: 53 push %ebx <== NOT EXECUTED 10f67d: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10f680: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10f683: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10f686: 39 0d 20 02 12 00 cmp %ecx,0x120220 <== NOT EXECUTED 10f68c: 76 1e jbe 10f6ac <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; 10f68e: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 10f691: a1 24 02 12 00 mov 0x120224,%eax <== NOT EXECUTED 10f696: 8b 04 d0 mov (%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10f699: 85 c0 test %eax,%eax <== NOT EXECUTED 10f69b: 74 14 je 10f6b1 <== NOT EXECUTED 10f69d: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10f6a0: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10f6a3: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10f6a6: 5b pop %ebx <== NOT EXECUTED 10f6a7: 5e pop %esi <== NOT EXECUTED 10f6a8: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10f6a9: ff e0 jmp *%eax <== NOT EXECUTED 10f6ab: 90 nop <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10f6ac: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 10f6b1: 5b pop %ebx <== NOT EXECUTED 10f6b2: 5e pop %esi <== NOT EXECUTED 10f6b3: c9 leave <== NOT EXECUTED 10f6b4: c3 ret <== NOT EXECUTED 00106d48 : rtems_status_code rtems_io_lookup_name( const char *name, rtems_driver_name_t *device_info ) { 106d48: 55 push %ebp <== NOT EXECUTED 106d49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106d4b: 57 push %edi <== NOT EXECUTED 106d4c: 56 push %esi <== NOT EXECUTED 106d4d: 53 push %ebx <== NOT EXECUTED 106d4e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 106d51: 8b 7d 08 mov 0x8(%ebp),%edi <== 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 ); 106d54: 6a 01 push $0x1 <== NOT EXECUTED 106d56: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 106d59: 56 push %esi <== NOT EXECUTED 106d5a: 6a 00 push $0x0 <== NOT EXECUTED 106d5c: 57 push %edi <== NOT EXECUTED 106d5d: e8 fa 01 00 00 call 106f5c <== NOT EXECUTED 106d62: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_jnode = loc.node_access; 106d64: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 106d67: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED if ( !loc.ops->node_type_h ) { 106d6a: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 106d6d: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 106d70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106d73: 85 d2 test %edx,%edx <== NOT EXECUTED 106d75: 74 39 je 106db0 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } node_type = (*loc.ops->node_type_h)( &loc ); 106d77: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106d7a: 56 push %esi <== NOT EXECUTED 106d7b: ff d2 call *%edx <== NOT EXECUTED if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) { 106d7d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106d80: 85 db test %ebx,%ebx <== NOT EXECUTED 106d82: 74 54 je 106dd8 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 106d84: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 106d87: 85 c0 test %eax,%eax <== NOT EXECUTED 106d89: 0f 84 95 00 00 00 je 106e24 <== NOT EXECUTED 106d8f: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 106d92: 85 c0 test %eax,%eax <== NOT EXECUTED 106d94: 0f 84 8a 00 00 00 je 106e24 <== NOT EXECUTED 106d9a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106d9d: 56 push %esi <== NOT EXECUTED 106d9e: ff d0 call *%eax <== NOT EXECUTED 106da0: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 106da5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &loc ); #endif return RTEMS_SUCCESSFUL; } 106da8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106dab: 5b pop %ebx <== NOT EXECUTED 106dac: 5e pop %esi <== NOT EXECUTED 106dad: 5f pop %edi <== NOT EXECUTED 106dae: c9 leave <== NOT EXECUTED 106daf: c3 ret <== NOT EXECUTED result = rtems_filesystem_evaluate_path( name, 0x00, &loc, true ); the_jnode = loc.node_access; if ( !loc.ops->node_type_h ) { rtems_filesystem_freenode( &loc ); 106db0: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 106db3: 85 c0 test %eax,%eax <== NOT EXECUTED 106db5: 74 09 je 106dc0 <== NOT EXECUTED 106db7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106dba: 56 push %esi <== NOT EXECUTED 106dbb: ff d0 call *%eax <== NOT EXECUTED 106dbd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 106dc0: e8 bb 9e 00 00 call 110c80 <__errno> <== NOT EXECUTED 106dc5: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 106dcb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED rtems_filesystem_freenode( &loc ); #endif return RTEMS_SUCCESSFUL; } 106dd0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106dd3: 5b pop %ebx <== NOT EXECUTED 106dd4: 5e pop %esi <== NOT EXECUTED 106dd5: 5f pop %edi <== NOT EXECUTED 106dd6: c9 leave <== NOT EXECUTED 106dd7: c3 ret <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } node_type = (*loc.ops->node_type_h)( &loc ); if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) { 106dd8: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 106ddb: 75 a7 jne 106d84 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); return RTEMS_UNSATISFIED; } device_info->device_name = (char *) name; 106ddd: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 106de0: 89 3a mov %edi,(%edx) <== NOT EXECUTED device_info->device_name_length = strlen( name ); 106de2: 31 c0 xor %eax,%eax <== NOT EXECUTED 106de4: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 106de9: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 106deb: f7 d1 not %ecx <== NOT EXECUTED 106ded: 49 dec %ecx <== NOT EXECUTED 106dee: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED device_info->major = the_jnode->info.device.major; 106df1: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 106df4: 8b 42 50 mov 0x50(%edx),%eax <== NOT EXECUTED 106df7: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 106dfa: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED device_info->minor = the_jnode->info.device.minor; 106dfd: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 106e00: 8b 42 54 mov 0x54(%edx),%eax <== NOT EXECUTED 106e03: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 106e06: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 106e09: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 106e0c: 85 c0 test %eax,%eax <== NOT EXECUTED 106e0e: 74 24 je 106e34 <== NOT EXECUTED 106e10: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 106e13: 85 c0 test %eax,%eax <== NOT EXECUTED 106e15: 74 1d je 106e34 <== NOT EXECUTED 106e17: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106e1a: 56 push %esi <== NOT EXECUTED 106e1b: ff d0 call *%eax <== NOT EXECUTED 106e1d: 31 c0 xor %eax,%eax <== NOT EXECUTED 106e1f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106e22: eb 84 jmp 106da8 <== NOT EXECUTED 106e24: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED #endif return RTEMS_SUCCESSFUL; } 106e29: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106e2c: 5b pop %ebx <== NOT EXECUTED 106e2d: 5e pop %esi <== NOT EXECUTED 106e2e: 5f pop %edi <== NOT EXECUTED 106e2f: c9 leave <== NOT EXECUTED 106e30: c3 ret <== NOT EXECUTED 106e31: 8d 76 00 lea 0x0(%esi),%esi <== 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 ); 106e34: 31 c0 xor %eax,%eax 106e36: e9 6d ff ff ff jmp 106da8 <== NOT EXECUTED 00110964 : rtems_status_code rtems_io_open( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 110964: 55 push %ebp <== NOT EXECUTED 110965: 89 e5 mov %esp,%ebp <== NOT EXECUTED 110967: 56 push %esi <== NOT EXECUTED 110968: 53 push %ebx <== NOT EXECUTED 110969: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 11096c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11096f: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 110972: 39 0d 20 02 12 00 cmp %ecx,0x120220 <== NOT EXECUTED 110978: 76 1e jbe 110998 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; 11097a: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 11097d: a1 24 02 12 00 mov 0x120224,%eax <== NOT EXECUTED 110982: 8b 44 d0 04 mov 0x4(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 110986: 85 c0 test %eax,%eax <== NOT EXECUTED 110988: 74 13 je 11099d <== NOT EXECUTED 11098a: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 11098d: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 110990: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 110993: 5b pop %ebx <== NOT EXECUTED 110994: 5e pop %esi <== NOT EXECUTED 110995: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 110996: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 110998: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 11099d: 5b pop %ebx <== NOT EXECUTED 11099e: 5e pop %esi <== NOT EXECUTED 11099f: c9 leave <== NOT EXECUTED 1109a0: c3 ret <== NOT EXECUTED 001109a4 : rtems_status_code rtems_io_read( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 1109a4: 55 push %ebp <== NOT EXECUTED 1109a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1109a7: 56 push %esi <== NOT EXECUTED 1109a8: 53 push %ebx <== NOT EXECUTED 1109a9: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1109ac: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1109af: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 1109b2: 39 0d 20 02 12 00 cmp %ecx,0x120220 <== NOT EXECUTED 1109b8: 76 1e jbe 1109d8 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; 1109ba: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 1109bd: a1 24 02 12 00 mov 0x120224,%eax <== NOT EXECUTED 1109c2: 8b 44 d0 0c mov 0xc(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 1109c6: 85 c0 test %eax,%eax <== NOT EXECUTED 1109c8: 74 13 je 1109dd <== NOT EXECUTED 1109ca: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 1109cd: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 1109d0: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 1109d3: 5b pop %ebx <== NOT EXECUTED 1109d4: 5e pop %esi <== NOT EXECUTED 1109d5: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 1109d6: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 1109d8: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 1109dd: 5b pop %ebx <== NOT EXECUTED 1109de: 5e pop %esi <== NOT EXECUTED 1109df: c9 leave <== NOT EXECUTED 1109e0: c3 ret <== NOT EXECUTED 0010b894 : rtems_status_code rtems_io_register_driver( rtems_device_major_number major, const rtems_driver_address_table *driver_table, rtems_device_major_number *registered_major ) { 10b894: 55 push %ebp <== NOT EXECUTED 10b895: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b897: 57 push %edi <== NOT EXECUTED 10b898: 56 push %esi <== NOT EXECUTED 10b899: 53 push %ebx <== NOT EXECUTED 10b89a: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b89d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b8a0: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10b8a3: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 10b8a6: 85 f6 test %esi,%esi <== NOT EXECUTED 10b8a8: 0f 84 c6 00 00 00 je 10b974 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 10b8ae: 85 db test %ebx,%ebx <== NOT EXECUTED 10b8b0: 0f 84 be 00 00 00 je 10b974 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 10b8b6: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10b8b8: 85 c0 test %eax,%eax <== NOT EXECUTED 10b8ba: 0f 84 a8 00 00 00 je 10b968 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; *registered_major = 0; 10b8c0: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 10b8c6: a1 24 2a 12 00 mov 0x122a24,%eax <== NOT EXECUTED 10b8cb: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10b8cd: 76 5d jbe 10b92c <== NOT EXECUTED /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 10b8cf: 85 d2 test %edx,%edx <== NOT EXECUTED 10b8d1: 75 65 jne 10b938 <== NOT EXECUTED bool found = false; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 10b8d3: 89 c2 mov %eax,%edx <== NOT EXECUTED 10b8d5: 4a dec %edx <== NOT EXECUTED 10b8d6: 0f 84 80 00 00 00 je 10b95c <== NOT EXECUTED 10b8dc: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10b8df: 8d 04 c5 e8 ff ff ff lea -0x18(,%eax,8),%eax <== NOT EXECUTED 10b8e6: 03 05 28 2a 12 00 add 0x122a28,%eax <== NOT EXECUTED 10b8ec: eb 08 jmp 10b8f6 <== NOT EXECUTED 10b8ee: 66 90 xchg %ax,%ax <== NOT EXECUTED 10b8f0: 83 e8 18 sub $0x18,%eax <== NOT EXECUTED 10b8f3: 4a dec %edx <== NOT EXECUTED 10b8f4: 74 66 je 10b95c <== NOT EXECUTED 10b8f6: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( !_IO_Driver_address_table[major].initialization_entry && 10b8f8: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10b8fa: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b8fc: 75 f2 jne 10b8f0 <== NOT EXECUTED 10b8fe: 8b 48 04 mov 0x4(%eax),%ecx <== NOT EXECUTED 10b901: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b903: 75 eb jne 10b8f0 <== NOT EXECUTED if ( _IO_Driver_address_table[major].initialization_entry || _IO_Driver_address_table[major].open_entry ) return RTEMS_RESOURCE_IN_USE; _IO_Driver_address_table[major] = *driver_table; 10b905: b8 06 00 00 00 mov $0x6,%eax <== NOT EXECUTED 10b90a: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b90c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *registered_major = major; 10b90e: 89 13 mov %edx,(%ebx) <== NOT EXECUTED return rtems_io_initialize( major, 0, NULL ); 10b910: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) <== NOT EXECUTED 10b917: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) <== NOT EXECUTED 10b91e: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10b921: 59 pop %ecx <== NOT EXECUTED 10b922: 5b pop %ebx <== NOT EXECUTED 10b923: 5e pop %esi <== NOT EXECUTED 10b924: 5f pop %edi <== NOT EXECUTED 10b925: c9 leave <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b926: e9 f1 fd ff ff jmp 10b71c <== NOT EXECUTED 10b92b: 90 nop <== NOT EXECUTED *registered_major = 0; /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 10b92c: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); } 10b931: 5a pop %edx <== NOT EXECUTED 10b932: 5b pop %ebx <== NOT EXECUTED 10b933: 5e pop %esi <== NOT EXECUTED 10b934: 5f pop %edi <== NOT EXECUTED 10b935: c9 leave <== NOT EXECUTED 10b936: c3 ret <== NOT EXECUTED 10b937: 90 nop <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 10b938: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10b93b: 8d 3c c5 00 00 00 00 lea 0x0(,%eax,8),%edi <== NOT EXECUTED 10b942: 03 3d 28 2a 12 00 add 0x122a28,%edi <== NOT EXECUTED 10b948: 8b 07 mov (%edi),%eax <== NOT EXECUTED 10b94a: 85 c0 test %eax,%eax <== NOT EXECUTED 10b94c: 74 32 je 10b980 <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b94e: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED } 10b953: 5a pop %edx <== NOT EXECUTED 10b954: 5b pop %ebx <== NOT EXECUTED 10b955: 5e pop %esi <== NOT EXECUTED 10b956: 5f pop %edi <== NOT EXECUTED 10b957: c9 leave <== NOT EXECUTED 10b958: c3 ret <== NOT EXECUTED 10b959: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b95c: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED } 10b961: 5a pop %edx <== NOT EXECUTED 10b962: 5b pop %ebx <== NOT EXECUTED 10b963: 5e pop %esi <== NOT EXECUTED 10b964: 5f pop %edi <== NOT EXECUTED 10b965: c9 leave <== NOT EXECUTED 10b966: c3 ret <== NOT EXECUTED 10b967: 90 nop <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !registered_major ) return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 10b968: 8b 7e 04 mov 0x4(%esi),%edi <== NOT EXECUTED 10b96b: 85 ff test %edi,%edi <== NOT EXECUTED 10b96d: 0f 85 4d ff ff ff jne 10b8c0 <== NOT EXECUTED 10b973: 90 nop <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b974: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } 10b979: 5a pop %edx <== NOT EXECUTED 10b97a: 5b pop %ebx <== NOT EXECUTED 10b97b: 5e pop %esi <== NOT EXECUTED 10b97c: 5f pop %edi <== NOT EXECUTED 10b97d: c9 leave <== NOT EXECUTED 10b97e: c3 ret <== NOT EXECUTED 10b97f: 90 nop <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 10b980: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 10b983: 85 c0 test %eax,%eax <== NOT EXECUTED 10b985: 75 c7 jne 10b94e <== NOT EXECUTED 10b987: e9 79 ff ff ff jmp 10b905 <== NOT EXECUTED 00106e3c : rtems_status_code rtems_io_register_name( const char *device_name, rtems_device_major_number major, rtems_device_minor_number minor ) { 106e3c: 55 push %ebp <== NOT EXECUTED 106e3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106e3f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 106e42: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 106e45: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED #if !defined(RTEMS_UNIX) int status; dev_t dev; dev = rtems_filesystem_make_dev_t( major, minor ); status = mknod( device_name, 0777 | S_IFCHR, dev ); 106e48: 52 push %edx <== NOT EXECUTED 106e49: 50 push %eax <== NOT EXECUTED 106e4a: 68 ff 21 00 00 push $0x21ff <== NOT EXECUTED 106e4f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106e52: e8 19 05 00 00 call 107370 <== NOT EXECUTED /* this is the only error returned by the old version */ if ( status ) 106e57: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106e5a: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 106e5d: 19 c0 sbb %eax,%eax <== NOT EXECUTED 106e5f: f7 d0 not %eax <== NOT EXECUTED 106e61: 83 e0 05 and $0x5,%eax <== NOT EXECUTED return RTEMS_TOO_MANY; #endif return RTEMS_SUCCESSFUL; } 106e64: c9 leave <== NOT EXECUTED 106e65: c3 ret <== NOT EXECUTED 0010b98c : */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 10b98c: 55 push %ebp <== NOT EXECUTED 10b98d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b98f: 57 push %edi <== NOT EXECUTED 10b990: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b993: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( major < _IO_Number_of_drivers ) { 10b996: 39 05 24 2a 12 00 cmp %eax,0x122a24 <== NOT EXECUTED 10b99c: 77 0a ja 10b9a8 <== NOT EXECUTED 10b99e: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED sizeof( rtems_driver_address_table ) ); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10b9a3: 5a pop %edx <== NOT EXECUTED 10b9a4: 5f pop %edi <== NOT EXECUTED 10b9a5: c9 leave <== NOT EXECUTED 10b9a6: c3 ret <== NOT EXECUTED 10b9a7: 90 nop <== NOT EXECUTED rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { if ( major < _IO_Number_of_drivers ) { memset( 10b9a8: 8d 3c 40 lea (%eax,%eax,2),%edi <== NOT EXECUTED 10b9ab: c1 e7 03 shl $0x3,%edi <== NOT EXECUTED 10b9ae: 03 3d 28 2a 12 00 add 0x122a28,%edi <== NOT EXECUTED 10b9b4: b9 18 00 00 00 mov $0x18,%ecx <== NOT EXECUTED 10b9b9: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b9bb: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 10b9bd: 31 c0 xor %eax,%eax <== NOT EXECUTED sizeof( rtems_driver_address_table ) ); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10b9bf: 5a pop %edx <== NOT EXECUTED 10b9c0: 5f pop %edi <== NOT EXECUTED 10b9c1: c9 leave <== NOT EXECUTED 10b9c2: c3 ret <== NOT EXECUTED 001109e4 : rtems_status_code rtems_io_write( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 1109e4: 55 push %ebp <== NOT EXECUTED 1109e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1109e7: 56 push %esi <== NOT EXECUTED 1109e8: 53 push %ebx <== NOT EXECUTED 1109e9: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1109ec: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1109ef: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 1109f2: 39 0d 20 02 12 00 cmp %ecx,0x120220 <== NOT EXECUTED 1109f8: 76 1e jbe 110a18 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; 1109fa: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 1109fd: a1 24 02 12 00 mov 0x120224,%eax <== NOT EXECUTED 110a02: 8b 44 d0 10 mov 0x10(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 110a06: 85 c0 test %eax,%eax <== NOT EXECUTED 110a08: 74 13 je 110a1d <== NOT EXECUTED 110a0a: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 110a0d: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 110a10: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 110a13: 5b pop %ebx <== NOT EXECUTED 110a14: 5e pop %esi <== NOT EXECUTED 110a15: c9 leave <== NOT EXECUTED if ( major >= _IO_Number_of_drivers ) return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 110a16: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 110a18: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; } 110a1d: 5b pop %ebx <== NOT EXECUTED 110a1e: 5e pop %esi <== NOT EXECUTED 110a1f: c9 leave <== NOT EXECUTED 110a20: c3 ret <== NOT EXECUTED 0010c980 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10c980: 55 push %ebp <== NOT EXECUTED 10c981: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c983: 57 push %edi <== NOT EXECUTED 10c984: 56 push %esi <== NOT EXECUTED 10c985: 53 push %ebx <== NOT EXECUTED 10c986: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10c989: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c98c: 85 c0 test %eax,%eax <== NOT EXECUTED 10c98e: 74 47 je 10c9d7 <== NOT EXECUTED return; 10c990: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 10c995: 8b 04 bd ac b7 12 00 mov 0x12b7ac(,%edi,4),%eax <== NOT EXECUTED 10c99c: 85 c0 test %eax,%eax <== NOT EXECUTED 10c99e: 74 31 je 10c9d1 <== NOT EXECUTED continue; information = _Objects_Information_table[ api_index ][ 1 ]; 10c9a0: 8b 70 04 mov 0x4(%eax),%esi <== NOT EXECUTED if ( information ) { 10c9a3: 85 f6 test %esi,%esi <== NOT EXECUTED 10c9a5: 74 2a je 10c9d1 <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { 10c9a7: 66 83 7e 10 00 cmpw $0x0,0x10(%esi) <== NOT EXECUTED 10c9ac: 74 23 je 10c9d1 <== NOT EXECUTED 10c9ae: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10c9b3: 90 nop <== NOT EXECUTED the_thread = (Thread_Control *)information->local_table[ i ]; 10c9b4: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 10c9b7: 8b 04 98 mov (%eax,%ebx,4),%eax <== NOT EXECUTED if ( !the_thread ) 10c9ba: 85 c0 test %eax,%eax <== NOT EXECUTED 10c9bc: 74 0a je 10c9c8 <== NOT EXECUTED continue; (*routine)(the_thread); 10c9be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c9c1: 50 push %eax <== NOT EXECUTED 10c9c2: ff 55 08 call *0x8(%ebp) <== NOT EXECUTED 10c9c5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 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++ ) { 10c9c8: 43 inc %ebx <== NOT EXECUTED 10c9c9: 0f b7 46 10 movzwl 0x10(%esi),%eax <== NOT EXECUTED 10c9cd: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10c9cf: 73 e3 jae 10c9b4 <== NOT EXECUTED if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10c9d1: 47 inc %edi <== NOT EXECUTED if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 10c9d2: 83 ff 05 cmp $0x5,%edi <== NOT EXECUTED 10c9d5: 75 be jne 10c995 <== NOT EXECUTED (*routine)(the_thread); } } } } 10c9d7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c9da: 5b pop %ebx <== NOT EXECUTED 10c9db: 5e pop %esi <== NOT EXECUTED 10c9dc: 5f pop %edi <== NOT EXECUTED 10c9dd: c9 leave <== NOT EXECUTED 10c9de: c3 ret <== NOT EXECUTED 0010e884 : * 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 ) { 10e884: 55 push %ebp <== NOT EXECUTED 10e885: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e887: 57 push %edi <== NOT EXECUTED 10e888: 56 push %esi <== NOT EXECUTED 10e889: 53 push %ebx <== NOT EXECUTED 10e88a: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED rtems_libio_t *iop, *next; rtems_status_code rc; rtems_id sema; rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10e88d: 6a 00 push $0x0 <== NOT EXECUTED 10e88f: 6a 00 push $0x0 <== NOT EXECUTED 10e891: ff 35 38 f6 11 00 pushl 0x11f638 <== NOT EXECUTED 10e897: e8 10 bb ff ff call 10a3ac <== NOT EXECUTED if (rtems_libio_iop_freelist) { 10e89c: 8b 15 34 f6 11 00 mov 0x11f634,%edx <== NOT EXECUTED 10e8a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e8a5: 85 d2 test %edx,%edx <== NOT EXECUTED 10e8a7: 75 1b jne 10e8c4 <== NOT EXECUTED } failed: iop = 0; done: 10e8a9: 31 db xor %ebx,%ebx <== NOT EXECUTED rtems_semaphore_release( rtems_libio_semaphore ); 10e8ab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e8ae: ff 35 38 f6 11 00 pushl 0x11f638 <== NOT EXECUTED 10e8b4: e8 eb bb ff ff call 10a4a4 <== NOT EXECUTED return iop; } 10e8b9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e8bb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e8be: 5b pop %ebx <== NOT EXECUTED 10e8bf: 5e pop %esi <== NOT EXECUTED 10e8c0: 5f pop %edi <== NOT EXECUTED 10e8c1: c9 leave <== NOT EXECUTED 10e8c2: c3 ret <== NOT EXECUTED 10e8c3: 90 nop <== NOT EXECUTED rtems_id sema; rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); if (rtems_libio_iop_freelist) { rc = rtems_semaphore_create( 10e8c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e8c7: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10e8ca: 50 push %eax <== NOT EXECUTED 10e8cb: 6a 00 push $0x0 <== NOT EXECUTED 10e8cd: 6a 54 push $0x54 <== NOT EXECUTED 10e8cf: 6a 01 push $0x1 <== NOT EXECUTED 10e8d1: 89 d1 mov %edx,%ecx <== NOT EXECUTED 10e8d3: 2b 0d 30 f6 11 00 sub 0x11f630,%ecx <== NOT EXECUTED 10e8d9: c1 f9 02 sar $0x2,%ecx <== NOT EXECUTED 10e8dc: 8d 14 89 lea (%ecx,%ecx,4),%edx <== NOT EXECUTED 10e8df: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e8e2: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e8e4: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 10e8e7: 29 d0 sub %edx,%eax <== NOT EXECUTED 10e8e9: 89 c2 mov %eax,%edx <== NOT EXECUTED 10e8eb: c1 e2 0c shl $0xc,%edx <== NOT EXECUTED 10e8ee: 01 d0 add %edx,%eax <== NOT EXECUTED 10e8f0: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED 10e8f3: 8d 04 41 lea (%ecx,%eax,2),%eax <== NOT EXECUTED 10e8f6: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10e8f9: 01 c8 add %ecx,%eax <== NOT EXECUTED 10e8fb: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED 10e8fe: 0d 00 49 42 4c or $0x4c424900,%eax <== NOT EXECUTED 10e903: 50 push %eax <== NOT EXECUTED 10e904: e8 23 b8 ff ff call 10a12c <== NOT EXECUTED 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &sema ); if (rc != RTEMS_SUCCESSFUL) 10e909: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10e90c: 85 c0 test %eax,%eax <== NOT EXECUTED 10e90e: 75 99 jne 10e8a9 <== NOT EXECUTED goto failed; iop = rtems_libio_iop_freelist; 10e910: 8b 1d 34 f6 11 00 mov 0x11f634,%ebx <== NOT EXECUTED next = iop->data1; 10e916: 8b 73 28 mov 0x28(%ebx),%esi <== NOT EXECUTED (void) memset( iop, 0, sizeof(rtems_libio_t) ); 10e919: b9 34 00 00 00 mov $0x34,%ecx <== NOT EXECUTED 10e91e: 31 d2 xor %edx,%edx <== NOT EXECUTED 10e920: 89 df mov %ebx,%edi <== NOT EXECUTED 10e922: 88 d0 mov %dl,%al <== NOT EXECUTED 10e924: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED iop->flags = LIBIO_FLAGS_OPEN; 10e926: c7 43 0c 00 01 00 00 movl $0x100,0xc(%ebx) <== NOT EXECUTED iop->sem = sema; 10e92d: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10e930: 89 53 20 mov %edx,0x20(%ebx) <== NOT EXECUTED rtems_libio_iop_freelist = next; 10e933: 89 35 34 f6 11 00 mov %esi,0x11f634 <== NOT EXECUTED 10e939: e9 6d ff ff ff jmp 10e8ab <== NOT EXECUTED 0010e940 : }; uint32_t rtems_libio_fcntl_flags( uint32_t fcntl_flags ) { 10e940: 55 push %ebp <== NOT EXECUTED 10e941: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e943: 56 push %esi <== NOT EXECUTED 10e944: 53 push %ebx <== NOT EXECUTED 10e945: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED * Access mode is a small integer */ access_modes = fcntl_flags & O_ACCMODE; fcntl_flags &= ~O_ACCMODE; flags = rtems_assoc_local_by_remote( access_modes_assoc, access_modes ); 10e948: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e94b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e94d: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 10e950: 50 push %eax <== NOT EXECUTED 10e951: 68 20 95 11 00 push $0x119520 <== NOT EXECUTED 10e956: e8 41 1a 00 00 call 11039c <== NOT EXECUTED 10e95b: 89 c6 mov %eax,%esi <== NOT EXECUTED /* * Everything else is single bits */ flags |= 10e95d: 58 pop %eax <== NOT EXECUTED 10e95e: 5a pop %edx <== NOT EXECUTED 10e95f: 83 e3 fc and $0xfffffffc,%ebx <== NOT EXECUTED 10e962: 53 push %ebx <== NOT EXECUTED 10e963: 68 60 95 11 00 push $0x119560 <== NOT EXECUTED 10e968: e8 eb 19 00 00 call 110358 <== NOT EXECUTED 10e96d: 09 f0 or %esi,%eax <== NOT EXECUTED rtems_assoc_local_by_remote_bitfield(status_flags_assoc, fcntl_flags); return flags; } 10e96f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e972: 5b pop %ebx <== NOT EXECUTED 10e973: 5e pop %esi <== NOT EXECUTED 10e974: c9 leave <== NOT EXECUTED 10e975: c3 ret <== NOT EXECUTED 0010e82c : */ void rtems_libio_free( rtems_libio_t *iop ) { 10e82c: 55 push %ebp <== NOT EXECUTED 10e82d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e82f: 53 push %ebx <== NOT EXECUTED 10e830: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e833: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10e836: 6a 00 push $0x0 <== NOT EXECUTED 10e838: 6a 00 push $0x0 <== NOT EXECUTED 10e83a: ff 35 38 f6 11 00 pushl 0x11f638 <== NOT EXECUTED 10e840: e8 67 bb ff ff call 10a3ac <== NOT EXECUTED if (iop->sem) 10e845: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 10e848: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e84b: 85 c0 test %eax,%eax <== NOT EXECUTED 10e84d: 74 0c je 10e85b <== NOT EXECUTED rtems_semaphore_delete(iop->sem); 10e84f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e852: 50 push %eax <== NOT EXECUTED 10e853: e8 b0 ba ff ff call 10a308 <== NOT EXECUTED 10e858: 83 c4 10 add $0x10,%esp <== NOT EXECUTED iop->flags &= ~LIBIO_FLAGS_OPEN; 10e85b: 81 63 0c ff fe ff ff andl $0xfffffeff,0xc(%ebx) <== NOT EXECUTED iop->data1 = rtems_libio_iop_freelist; 10e862: a1 34 f6 11 00 mov 0x11f634,%eax <== NOT EXECUTED 10e867: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED rtems_libio_iop_freelist = iop; 10e86a: 89 1d 34 f6 11 00 mov %ebx,0x11f634 <== NOT EXECUTED rtems_semaphore_release(rtems_libio_semaphore); 10e870: a1 38 f6 11 00 mov 0x11f638,%eax <== NOT EXECUTED 10e875: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10e878: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e87b: c9 leave <== NOT EXECUTED iop->flags &= ~LIBIO_FLAGS_OPEN; iop->data1 = rtems_libio_iop_freelist; rtems_libio_iop_freelist = iop; rtems_semaphore_release(rtems_libio_semaphore); 10e87c: e9 23 bc ff ff jmp 10a4a4 <== NOT EXECUTED 0010711c : * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) { 10711c: 55 push %ebp <== NOT EXECUTED 10711d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10711f: 53 push %ebx <== NOT EXECUTED 107120: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED rtems_status_code rc; int i; rtems_libio_t *iop; if (rtems_libio_number_iops > 0) 107123: a1 00 b1 11 00 mov 0x11b100,%eax <== NOT EXECUTED 107128: 85 c0 test %eax,%eax <== NOT EXECUTED 10712a: 74 50 je 10717c <== NOT EXECUTED { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, 10712c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10712f: 6a 34 push $0x34 <== NOT EXECUTED 107131: 50 push %eax <== NOT EXECUTED 107132: e8 bd 73 00 00 call 10e4f4 <== NOT EXECUTED 107137: 89 c3 mov %eax,%ebx <== NOT EXECUTED 107139: 89 1d 30 f6 11 00 mov %ebx,0x11f630 <== NOT EXECUTED sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) 10713f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107142: 85 db test %ebx,%ebx <== NOT EXECUTED 107144: 74 5e je 1071a4 <== NOT EXECUTED rtems_fatal_error_occurred(RTEMS_NO_MEMORY); iop = rtems_libio_iop_freelist = rtems_libio_iops; 107146: 89 1d 34 f6 11 00 mov %ebx,0x11f634 <== NOT EXECUTED for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++) 10714c: 8b 0d 00 b1 11 00 mov 0x11b100,%ecx <== NOT EXECUTED 107152: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED 107155: 74 1e je 107175 <== NOT EXECUTED 107157: 8d 43 34 lea 0x34(%ebx),%eax <== NOT EXECUTED 10715a: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10715f: 90 nop <== NOT EXECUTED iop->data1 = iop + 1; 107160: 89 40 f4 mov %eax,-0xc(%eax) <== NOT EXECUTED 107163: 42 inc %edx <== NOT EXECUTED 107164: 83 c0 34 add $0x34,%eax <== NOT EXECUTED 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++) 107167: 39 ca cmp %ecx,%edx <== NOT EXECUTED 107169: 75 f5 jne 107160 <== NOT EXECUTED 10716b: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10716e: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 107171: 8d 44 83 cc lea -0x34(%ebx,%eax,4),%eax <== NOT EXECUTED iop->data1 = iop + 1; iop->data1 = NULL; 107175: c7 40 28 00 00 00 00 movl $0x0,0x28(%eax) <== NOT EXECUTED /* * Create the binary semaphore used to provide mutual exclusion * on the IOP Table. */ rc = rtems_semaphore_create( 10717c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10717f: 68 38 f6 11 00 push $0x11f638 <== NOT EXECUTED 107184: 6a 00 push $0x0 <== NOT EXECUTED 107186: 6a 54 push $0x54 <== NOT EXECUTED 107188: 6a 01 push $0x1 <== NOT EXECUTED 10718a: 68 4f 49 42 4c push $0x4c42494f <== NOT EXECUTED 10718f: e8 98 2f 00 00 call 10a12c <== NOT EXECUTED 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) 107194: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 107197: 85 c0 test %eax,%eax <== NOT EXECUTED 107199: 75 13 jne 1071ae <== NOT EXECUTED /* * Initialize the base file system infrastructure. */ rtems_filesystem_initialize(); } 10719b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10719e: c9 leave <== NOT EXECUTED /* * Initialize the base file system infrastructure. */ rtems_filesystem_initialize(); 10719f: e9 5c 72 00 00 jmp 10e400 <== NOT EXECUTED if (rtems_libio_number_iops > 0) { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) rtems_fatal_error_occurred(RTEMS_NO_MEMORY); 1071a4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1071a7: 6a 1a push $0x1a <== NOT EXECUTED 1071a9: e8 9a 38 00 00 call 10aa48 <== NOT EXECUTED RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) rtems_fatal_error_occurred( rc ); 1071ae: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1071b1: 50 push %eax <== NOT EXECUTED 1071b2: e8 91 38 00 00 call 10aa48 <== NOT EXECUTED 0010e764 : */ int rtems_libio_is_file_open( void *node_access ) { 10e764: 55 push %ebp <== NOT EXECUTED 10e765: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e767: 53 push %ebx <== NOT EXECUTED 10e768: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e76b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_libio_t *iop; int result=0; int i; rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10e76e: 6a 00 push $0x0 <== NOT EXECUTED 10e770: 6a 00 push $0x0 <== NOT EXECUTED 10e772: ff 35 38 f6 11 00 pushl 0x11f638 <== NOT EXECUTED 10e778: e8 2f bc ff ff call 10a3ac <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10e77d: 8b 15 30 f6 11 00 mov 0x11f630,%edx <== NOT EXECUTED 10e783: 8b 0d 00 b1 11 00 mov 0x11b100,%ecx <== NOT EXECUTED 10e789: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e78c: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10e78e: 74 17 je 10e7a7 <== NOT EXECUTED 10e790: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e792: eb 03 jmp 10e797 <== NOT EXECUTED 10e794: 83 c2 34 add $0x34,%edx <== NOT EXECUTED if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) { 10e797: f6 42 0d 01 testb $0x1,0xd(%edx) <== NOT EXECUTED 10e79b: 74 05 je 10e7a2 <== NOT EXECUTED /* * Check if this node is under the file system that we * are trying to dismount. */ if ( iop->pathinfo.node_access == node_access ) { 10e79d: 39 5a 10 cmp %ebx,0x10(%edx) <== NOT EXECUTED 10e7a0: 74 1e je 10e7c0 <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10e7a2: 40 inc %eax <== NOT EXECUTED 10e7a3: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10e7a5: 72 ed jb 10e794 <== NOT EXECUTED 10e7a7: 31 db xor %ebx,%ebx <== NOT EXECUTED break; } } } rtems_semaphore_release( rtems_libio_semaphore ); 10e7a9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e7ac: ff 35 38 f6 11 00 pushl 0x11f638 <== NOT EXECUTED 10e7b2: e8 ed bc ff ff call 10a4a4 <== NOT EXECUTED return result; } 10e7b7: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e7b9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e7bc: c9 leave <== NOT EXECUTED 10e7bd: c3 ret <== NOT EXECUTED 10e7be: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10e7c0: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10e7c5: eb e2 jmp 10e7a9 <== NOT EXECUTED 0010e7c8 : */ int rtems_libio_is_open_files_in_fs( rtems_filesystem_mount_table_entry_t * fs_mt_entry ) { 10e7c8: 55 push %ebp <== NOT EXECUTED 10e7c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e7cb: 53 push %ebx <== NOT EXECUTED 10e7cc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e7cf: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_libio_t *iop; int result = 0; int i; rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10e7d2: 6a 00 push $0x0 <== NOT EXECUTED 10e7d4: 6a 00 push $0x0 <== NOT EXECUTED 10e7d6: ff 35 38 f6 11 00 pushl 0x11f638 <== NOT EXECUTED 10e7dc: e8 cb bb ff ff call 10a3ac <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10e7e1: 8b 15 30 f6 11 00 mov 0x11f630,%edx <== NOT EXECUTED 10e7e7: 8b 0d 00 b1 11 00 mov 0x11b100,%ecx <== NOT EXECUTED 10e7ed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e7f0: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10e7f2: 74 17 je 10e80b <== NOT EXECUTED 10e7f4: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e7f6: eb 03 jmp 10e7fb <== NOT EXECUTED 10e7f8: 83 c2 34 add $0x34,%edx <== NOT EXECUTED if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) { 10e7fb: f6 42 0d 01 testb $0x1,0xd(%edx) <== NOT EXECUTED 10e7ff: 74 05 je 10e806 <== NOT EXECUTED /* * Check if this node is under the file system that we * are trying to dismount. */ if ( iop->pathinfo.mt_entry == fs_mt_entry ) { 10e801: 39 5a 1c cmp %ebx,0x1c(%edx) <== NOT EXECUTED 10e804: 74 1e je 10e824 <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10e806: 40 inc %eax <== NOT EXECUTED 10e807: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10e809: 72 ed jb 10e7f8 <== NOT EXECUTED 10e80b: 31 db xor %ebx,%ebx <== NOT EXECUTED break; } } } rtems_semaphore_release( rtems_libio_semaphore ); 10e80d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e810: ff 35 38 f6 11 00 pushl 0x11f638 <== NOT EXECUTED 10e816: e8 89 bc ff ff call 10a4a4 <== NOT EXECUTED return result; } 10e81b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e81d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e820: c9 leave <== NOT EXECUTED 10e821: c3 ret <== NOT EXECUTED 10e822: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10e824: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10e829: eb e2 jmp 10e80d <== NOT EXECUTED 00124fb4 : rtems_filesystem_freenode( &env->root_directory); free(env); } } rtems_status_code rtems_libio_set_private_env(void) { 124fb4: 55 push %ebp <== NOT EXECUTED 124fb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124fb7: 57 push %edi <== NOT EXECUTED 124fb8: 56 push %esi <== NOT EXECUTED 124fb9: 53 push %ebx <== NOT EXECUTED 124fba: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED rtems_status_code sc; rtems_id task_id; rtems_filesystem_location_info_t loc; sc=rtems_task_ident(RTEMS_SELF,0,&task_id); 124fbd: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 124fc0: 50 push %eax <== NOT EXECUTED 124fc1: 6a 00 push $0x0 <== NOT EXECUTED 124fc3: 6a 00 push $0x0 <== NOT EXECUTED 124fc5: e8 fa 14 00 00 call 1264c4 <== NOT EXECUTED 124fca: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 124fcc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124fcf: 85 c0 test %eax,%eax <== NOT EXECUTED 124fd1: 0f 85 8a 00 00 00 jne 125061 <== NOT EXECUTED /* Only for the first time a malloc is necesary */ if (rtems_current_user_env==&rtems_global_user_env) { 124fd7: 81 3d ec ba 14 00 40 cmpl $0x162640,0x14baec <== NOT EXECUTED 124fde: 26 16 00 <== NOT EXECUTED 124fe1: 0f 84 85 00 00 00 je 12506c <== NOT EXECUTED return sc; } rtems_current_user_env = tmp; }; *rtems_current_user_env = rtems_global_user_env; /* get the global values*/ 124fe7: 8b 3d ec ba 14 00 mov 0x14baec,%edi <== NOT EXECUTED 124fed: be 40 26 16 00 mov $0x162640,%esi <== NOT EXECUTED 124ff2: b9 10 00 00 00 mov $0x10,%ecx <== NOT EXECUTED 124ff7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED rtems_current_user_env->task_id=task_id; /* mark the local values*/ 124ff9: 8b 15 ec ba 14 00 mov 0x14baec,%edx <== NOT EXECUTED 124fff: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 125002: 89 02 mov %eax,(%edx) <== NOT EXECUTED /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 125004: 8d 7a 14 lea 0x14(%edx),%edi <== NOT EXECUTED 125007: a1 0c 1e 16 00 mov 0x161e0c,%eax <== NOT EXECUTED 12500c: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 12500f: b1 04 mov $0x4,%cl <== NOT EXECUTED 125011: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED * 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); 125013: 6a 00 push $0x0 <== NOT EXECUTED 125015: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 125018: 89 45 c8 mov %eax,-0x38(%ebp) <== NOT EXECUTED 12501b: 50 push %eax <== NOT EXECUTED 12501c: 6a 00 push $0x0 <== NOT EXECUTED 12501e: 68 a3 51 14 00 push $0x1451a3 <== NOT EXECUTED 125023: e8 04 62 fe ff call 10b22c <== NOT EXECUTED rtems_filesystem_root = loc; 125028: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED 12502d: 8d 78 14 lea 0x14(%eax),%edi <== NOT EXECUTED 125030: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 125035: 8b 75 c8 mov -0x38(%ebp),%esi <== NOT EXECUTED 125038: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED rtems_filesystem_evaluate_path("/", 0, &loc, 0); 12503a: 6a 00 push $0x0 <== NOT EXECUTED 12503c: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 12503f: 50 push %eax <== NOT EXECUTED 125040: 6a 00 push $0x0 <== NOT EXECUTED 125042: 68 a3 51 14 00 push $0x1451a3 <== NOT EXECUTED 125047: e8 e0 61 fe ff call 10b22c <== NOT EXECUTED rtems_filesystem_current = loc; 12504c: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED 125051: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 125054: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 125059: 8b 75 c8 mov -0x38(%ebp),%esi <== NOT EXECUTED 12505c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 12505e: 83 c4 20 add $0x20,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 125061: 89 d8 mov %ebx,%eax <== NOT EXECUTED 125063: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 125066: 5b pop %ebx <== NOT EXECUTED 125067: 5e pop %esi <== NOT EXECUTED 125068: 5f pop %edi <== NOT EXECUTED 125069: c9 leave <== NOT EXECUTED 12506a: c3 ret <== NOT EXECUTED 12506b: 90 nop <== NOT EXECUTED sc=rtems_task_ident(RTEMS_SELF,0,&task_id); 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)); 12506c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12506f: 6a 40 push $0x40 <== NOT EXECUTED 125071: e8 1e 68 fe ff call 10b894 <== NOT EXECUTED 125076: 89 c6 mov %eax,%esi <== NOT EXECUTED if (!tmp) 125078: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12507b: 85 c0 test %eax,%eax <== NOT EXECUTED 12507d: 74 29 je 1250a8 <== NOT EXECUTED #ifdef HAVE_USERENV_REFCNT tmp->refcnt = 1; #endif sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,(void(*)(void *))free_user_env); 12507f: 51 push %ecx <== NOT EXECUTED 125080: 68 b0 4e 12 00 push $0x124eb0 <== NOT EXECUTED 125085: 68 ec ba 14 00 push $0x14baec <== NOT EXECUTED 12508a: 6a 00 push $0x0 <== NOT EXECUTED 12508c: e8 e7 17 00 00 call 126878 <== NOT EXECUTED 125091: 89 c7 mov %eax,%edi <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) { 125093: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125096: 85 c0 test %eax,%eax <== NOT EXECUTED 125098: 75 12 jne 1250ac <== NOT EXECUTED * not initialized yet */ free(tmp); return sc; } rtems_current_user_env = tmp; 12509a: 89 35 ec ba 14 00 mov %esi,0x14baec <== NOT EXECUTED 1250a0: e9 42 ff ff ff jmp 124fe7 <== NOT EXECUTED 1250a5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 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) 1250a8: b3 1a mov $0x1a,%bl <== NOT EXECUTED 1250aa: eb b5 jmp 125061 <== 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); 1250ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1250af: 56 push %esi <== NOT EXECUTED 1250b0: e8 bb 62 fe ff call 10b370 <== NOT EXECUTED 1250b5: 89 fb mov %edi,%ebx <== NOT EXECUTED 1250b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1250ba: eb a5 jmp 125061 <== NOT EXECUTED 00124f0c : * 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) { 124f0c: 55 push %ebp <== NOT EXECUTED 124f0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124f0f: 53 push %ebx <== NOT EXECUTED 124f10: 83 ec 18 sub $0x18,%esp <== 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); 124f13: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 124f16: 50 push %eax <== NOT EXECUTED 124f17: 6a 00 push $0x0 <== NOT EXECUTED 124f19: 6a 00 push $0x0 <== NOT EXECUTED 124f1b: e8 a4 15 00 00 call 1264c4 <== NOT EXECUTED 124f20: 89 c2 mov %eax,%edx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 124f22: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124f25: 85 c0 test %eax,%eax <== NOT EXECUTED 124f27: 75 32 jne 124f5b <== NOT EXECUTED if (rtems_current_user_env->task_id==current_task_id) { 124f29: 8b 1d ec ba 14 00 mov 0x14baec,%ebx <== NOT EXECUTED 124f2f: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 124f31: 3b 45 f4 cmp -0xc(%ebp),%eax <== NOT EXECUTED 124f34: 74 2e je 124f64 <== 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, 124f36: 52 push %edx <== NOT EXECUTED 124f37: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 124f3a: 50 push %eax <== NOT EXECUTED 124f3b: 68 ec ba 14 00 push $0x14baec <== NOT EXECUTED 124f40: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124f43: e8 84 1a 00 00 call 1269cc <== NOT EXECUTED 124f48: 89 c2 mov %eax,%edx <== NOT EXECUTED (void*)&shared_user_env ); if (sc != RTEMS_SUCCESSFUL) 124f4a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124f4d: 85 c0 test %eax,%eax <== NOT EXECUTED 124f4f: 74 3b je 124f8c <== NOT EXECUTED return RTEMS_SUCCESSFUL; bailout: /* fallback to the global env */ rtems_current_user_env = &rtems_global_user_env; 124f51: c7 05 ec ba 14 00 40 movl $0x162640,0x14baec <== NOT EXECUTED 124f58: 26 16 00 <== NOT EXECUTED return sc; } 124f5b: 89 d0 mov %edx,%eax <== NOT EXECUTED 124f5d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 124f60: c9 leave <== NOT EXECUTED 124f61: c3 ret <== NOT EXECUTED 124f62: 66 90 xchg %ax,%ax <== 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); 124f64: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124f67: 68 ec ba 14 00 push $0x14baec <== NOT EXECUTED 124f6c: 6a 00 push $0x0 <== NOT EXECUTED 124f6e: e8 c5 19 00 00 call 126938 <== NOT EXECUTED 124f73: 89 c2 mov %eax,%edx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 124f75: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124f78: 85 c0 test %eax,%eax <== NOT EXECUTED 124f7a: 75 df jne 124f5b <== NOT EXECUTED free_user_env(tmp); 124f7c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124f7f: 53 push %ebx <== NOT EXECUTED 124f80: e8 2b ff ff ff call 124eb0 <== NOT EXECUTED 124f85: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124f88: eb ac jmp 124f36 <== NOT EXECUTED 124f8a: 66 90 xchg %ax,%ax <== NOT EXECUTED sc = rtems_task_variable_get(task_id,(void*)&rtems_current_user_env, (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); 124f8c: 50 push %eax <== NOT EXECUTED 124f8d: 68 b0 4e 12 00 push $0x124eb0 <== NOT EXECUTED 124f92: 68 ec ba 14 00 push $0x14baec <== NOT EXECUTED 124f97: 6a 00 push $0x0 <== NOT EXECUTED 124f99: e8 da 18 00 00 call 126878 <== NOT EXECUTED 124f9e: 89 c2 mov %eax,%edx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 124fa0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124fa3: 85 c0 test %eax,%eax <== NOT EXECUTED 124fa5: 75 aa jne 124f51 <== NOT EXECUTED goto bailout; /* the current_user_env is the same pointer that remote env */ rtems_current_user_env = shared_user_env; 124fa7: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 124faa: a3 ec ba 14 00 mov %eax,0x14baec <== NOT EXECUTED 124faf: eb aa jmp 124f5b <== NOT EXECUTED 0010e724 : */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) { 10e724: 55 push %ebp <== NOT EXECUTED 10e725: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e727: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10e72a: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e72c: 83 e0 06 and $0x6,%eax <== NOT EXECUTED 10e72f: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 10e732: 74 2c je 10e760 <== NOT EXECUTED fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { 10e734: f6 c2 02 test $0x2,%dl <== NOT EXECUTED 10e737: 75 23 jne 10e75c <== NOT EXECUTED 10e739: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e73b: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED 10e73e: 83 e0 01 and $0x1,%eax <== NOT EXECUTED fcntl_flags |= O_RDONLY; } else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) { fcntl_flags |= O_WRONLY; } if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) { 10e741: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 10e744: 74 03 je 10e749 <== NOT EXECUTED fcntl_flags |= O_NONBLOCK; 10e746: 80 cc 40 or $0x40,%ah <== NOT EXECUTED } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 10e749: f6 c6 02 test $0x2,%dh <== NOT EXECUTED 10e74c: 74 03 je 10e751 <== NOT EXECUTED fcntl_flags |= O_APPEND; 10e74e: 83 c8 08 or $0x8,%eax <== NOT EXECUTED } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 10e751: 80 e6 04 and $0x4,%dh <== NOT EXECUTED 10e754: 74 03 je 10e759 <== NOT EXECUTED fcntl_flags |= O_CREAT; 10e756: 80 cc 02 or $0x2,%ah <== NOT EXECUTED } return fcntl_flags; } 10e759: c9 leave <== NOT EXECUTED 10e75a: c3 ret <== NOT EXECUTED 10e75b: 90 nop <== NOT EXECUTED { uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { 10e75c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e75e: eb e1 jmp 10e741 <== NOT EXECUTED uint32_t flags ) { uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10e760: b0 02 mov $0x2,%al <== NOT EXECUTED 10e762: eb dd jmp 10e741 <== NOT EXECUTED 0010b94c : * size and thus we skip updating the statistics. */ void rtems_malloc_statistics_at_free( void *pointer ) { 10b94c: 55 push %ebp <== NOT EXECUTED 10b94d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b94f: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED size_t size; if (_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, pointer, &size) ) { 10b952: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b955: 50 push %eax <== NOT EXECUTED 10b956: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b959: 68 80 1d 16 00 push $0x161d80 <== NOT EXECUTED 10b95e: e8 3d 58 00 00 call 1111a0 <_Protected_heap_Get_block_size> <== NOT EXECUTED 10b963: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b966: 84 c0 test %al,%al <== NOT EXECUTED 10b968: 74 11 je 10b97b <== NOT EXECUTED MSBUMP(lifetime_freed, size); 10b96a: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED 10b96d: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b96f: 01 05 04 1e 16 00 add %eax,0x161e04 <== NOT EXECUTED 10b975: 11 15 08 1e 16 00 adc %edx,0x161e08 <== NOT EXECUTED } } 10b97b: c9 leave <== NOT EXECUTED 10b97c: c3 ret <== NOT EXECUTED 0010b980 : } void rtems_malloc_statistics_at_malloc( void *pointer ) { 10b980: 55 push %ebp <== NOT EXECUTED 10b981: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b983: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10b986: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED size_t actual_size = 0; uint32_t current_depth; rtems_malloc_statistics_t *s = &rtems_malloc_statistics; if ( !pointer ) 10b989: 85 d2 test %edx,%edx <== NOT EXECUTED 10b98b: 74 49 je 10b9d6 <== NOT EXECUTED void rtems_malloc_statistics_at_malloc( void *pointer ) { size_t actual_size = 0; 10b98d: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED rtems_malloc_statistics_t *s = &rtems_malloc_statistics; if ( !pointer ) return; _Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, pointer, &actual_size); 10b994: 50 push %eax <== NOT EXECUTED 10b995: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b998: 50 push %eax <== NOT EXECUTED 10b999: 52 push %edx <== NOT EXECUTED 10b99a: 68 80 1d 16 00 push $0x161d80 <== NOT EXECUTED 10b99f: e8 fc 57 00 00 call 1111a0 <_Protected_heap_Get_block_size> <== NOT EXECUTED MSBUMP(lifetime_allocated, actual_size); 10b9a4: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED 10b9a7: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b9a9: 03 05 fc 1d 16 00 add 0x161dfc,%eax <== NOT EXECUTED 10b9af: 13 15 00 1e 16 00 adc 0x161e00,%edx <== NOT EXECUTED 10b9b5: a3 fc 1d 16 00 mov %eax,0x161dfc <== NOT EXECUTED 10b9ba: 89 15 00 1e 16 00 mov %edx,0x161e00 <== NOT EXECUTED current_depth = s->lifetime_allocated - s->lifetime_freed; 10b9c0: 2b 05 04 1e 16 00 sub 0x161e04,%eax <== NOT EXECUTED if (current_depth > s->max_depth) 10b9c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b9c9: 3b 05 f8 1d 16 00 cmp 0x161df8,%eax <== NOT EXECUTED 10b9cf: 76 05 jbe 10b9d6 <== NOT EXECUTED s->max_depth = current_depth; 10b9d1: a3 f8 1d 16 00 mov %eax,0x161df8 <== NOT EXECUTED } 10b9d6: c9 leave <== NOT EXECUTED 10b9d7: c3 ret <== NOT EXECUTED 0010b9d8 : #include #include void rtems_malloc_statistics_initialize( void ) { 10b9d8: 55 push %ebp <== NOT EXECUTED 10b9d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b9db: 57 push %edi <== NOT EXECUTED 10b9dc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED /* * Zero all the statistics */ (void) memset(&rtems_malloc_statistics, 0, sizeof(rtems_malloc_statistics)); 10b9df: bf e0 1d 16 00 mov $0x161de0,%edi <== NOT EXECUTED 10b9e4: b9 2c 00 00 00 mov $0x2c,%ecx <== NOT EXECUTED 10b9e9: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b9eb: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED } 10b9ed: 5a pop %edx <== NOT EXECUTED 10b9ee: 5f pop %edi <== NOT EXECUTED 10b9ef: c9 leave <== NOT EXECUTED 10b9f0: c3 ret <== NOT EXECUTED 0010949c : int rtems_memalign( void **pointer, size_t alignment, size_t size ) { 10949c: 55 push %ebp <== NOT EXECUTED 10949d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10949f: 56 push %esi <== NOT EXECUTED 1094a0: 53 push %ebx <== NOT EXECUTED 1094a1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED void *return_this; /* * Parameter error checks */ if ( !pointer ) 1094a4: 85 f6 test %esi,%esi <== NOT EXECUTED 1094a6: 74 55 je 1094fd <== NOT EXECUTED return EINVAL; *pointer = NULL; 1094a8: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 1094ae: 83 3d 24 50 12 00 03 cmpl $0x3,0x125024 <== NOT EXECUTED 1094b5: 74 3d je 1094f4 <== NOT EXECUTED /* * * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 1094b7: e8 f4 f0 ff ff call 1085b0 <== NOT EXECUTED /* * Perform the aligned allocation requested */ return_this = _Protected_heap_Allocate_aligned( 1094bc: 50 push %eax <== NOT EXECUTED 1094bd: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1094c0: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1094c3: 68 00 4d 12 00 push $0x124d00 <== NOT EXECUTED 1094c8: e8 87 47 00 00 call 10dc54 <_Protected_heap_Allocate_aligned> <== NOT EXECUTED 1094cd: 89 c3 mov %eax,%ebx <== NOT EXECUTED &RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 1094cf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1094d2: 85 c0 test %eax,%eax <== NOT EXECUTED 1094d4: 74 36 je 10950c <== NOT EXECUTED return ENOMEM; /* * If configured, update the more involved statistics */ if ( rtems_malloc_statistics_helpers ) 1094d6: a1 04 2d 12 00 mov 0x122d04,%eax <== NOT EXECUTED 1094db: 85 c0 test %eax,%eax <== NOT EXECUTED 1094dd: 74 0a je 1094e9 <== NOT EXECUTED (*rtems_malloc_statistics_helpers->at_malloc)(pointer); 1094df: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1094e2: 56 push %esi <== NOT EXECUTED 1094e3: ff 50 04 call *0x4(%eax) <== NOT EXECUTED 1094e6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED */ if (rtems_malloc_boundary_helpers) (*rtems_malloc_boundary_helpers->at_malloc)(return_this, size); #endif *pointer = return_this; 1094e9: 89 1e mov %ebx,(%esi) <== NOT EXECUTED 1094eb: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 1094ed: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1094f0: 5b pop %ebx <== NOT EXECUTED 1094f1: 5e pop %esi <== NOT EXECUTED 1094f2: c9 leave <== NOT EXECUTED 1094f3: c3 ret <== NOT EXECUTED *pointer = NULL; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 1094f4: e8 5f f0 ff ff call 108558 <== NOT EXECUTED 1094f9: 84 c0 test %al,%al <== NOT EXECUTED 1094fb: 75 ba jne 1094b7 <== NOT EXECUTED if (rtems_malloc_boundary_helpers) (*rtems_malloc_boundary_helpers->at_malloc)(return_this, size); #endif *pointer = return_this; return 0; 1094fd: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED } 109502: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 109505: 5b pop %ebx <== NOT EXECUTED 109506: 5e pop %esi <== NOT EXECUTED 109507: c9 leave <== NOT EXECUTED 109508: c3 ret <== NOT EXECUTED 109509: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return_this = _Protected_heap_Allocate_aligned( &RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 10950c: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED 109511: eb da jmp 1094ed <== NOT EXECUTED 00112328 : Objects_Id id, const void *buffer, size_t size, uint32_t *count ) { 112328: 55 push %ebp <== NOT EXECUTED 112329: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11232b: 57 push %edi <== NOT EXECUTED 11232c: 56 push %esi <== NOT EXECUTED 11232d: 53 push %ebx <== NOT EXECUTED 11232e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 112331: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 112334: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 112337: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status core_status; if ( !buffer ) 11233a: 85 f6 test %esi,%esi <== NOT EXECUTED 11233c: 74 62 je 1123a0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !count ) 11233e: 85 db test %ebx,%ebx <== NOT EXECUTED 112340: 74 5e je 1123a0 <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 112342: 51 push %ecx <== NOT EXECUTED 112343: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 112346: 50 push %eax <== NOT EXECUTED 112347: 57 push %edi <== NOT EXECUTED 112348: 68 60 77 13 00 push $0x137760 <== NOT EXECUTED 11234d: e8 ee 48 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 112352: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112355: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 112358: 85 d2 test %edx,%edx <== NOT EXECUTED 11235a: 74 10 je 11236c <== NOT EXECUTED 11235c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112361: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112364: 5b pop %ebx <== NOT EXECUTED 112365: 5e pop %esi <== NOT EXECUTED 112366: 5f pop %edi <== NOT EXECUTED 112367: c9 leave <== NOT EXECUTED 112368: c3 ret <== NOT EXECUTED 112369: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 11236c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11236f: 53 push %ebx <== NOT EXECUTED 112370: 6a 00 push $0x0 <== NOT EXECUTED 112372: 57 push %edi <== NOT EXECUTED 112373: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 112376: 56 push %esi <== NOT EXECUTED 112377: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 11237a: 50 push %eax <== NOT EXECUTED 11237b: e8 1c 32 00 00 call 11559c <_CORE_message_queue_Broadcast> <== NOT EXECUTED 112380: 89 c3 mov %eax,%ebx <== NOT EXECUTED NULL, #endif count ); _Thread_Enable_dispatch(); 112382: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 112385: e8 fa 50 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED return 11238a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11238d: 53 push %ebx <== NOT EXECUTED 11238e: e8 5d 03 00 00 call 1126f0 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 112393: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112396: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112399: 5b pop %ebx <== NOT EXECUTED 11239a: 5e pop %esi <== NOT EXECUTED 11239b: 5f pop %edi <== NOT EXECUTED 11239c: c9 leave <== NOT EXECUTED 11239d: c3 ret <== NOT EXECUTED 11239e: 66 90 xchg %ax,%ax <== NOT EXECUTED #endif count ); _Thread_Enable_dispatch(); return 1123a0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1123a5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1123a8: 5b pop %ebx <== NOT EXECUTED 1123a9: 5e pop %esi <== NOT EXECUTED 1123aa: 5f pop %edi <== NOT EXECUTED 1123ab: c9 leave <== NOT EXECUTED 1123ac: c3 ret <== NOT EXECUTED 0010ee6c : uint32_t count, size_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) { 10ee6c: 55 push %ebp <== NOT EXECUTED 10ee6d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ee6f: 56 push %esi <== NOT EXECUTED 10ee70: 53 push %ebx <== NOT EXECUTED 10ee71: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ee74: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED CORE_message_queue_Attributes the_msgq_attributes; #if defined(RTEMS_MULTIPROCESSING) bool is_global; #endif if ( !rtems_is_name_valid( name ) ) 10ee77: 85 f6 test %esi,%esi <== NOT EXECUTED 10ee79: 74 31 je 10eeac <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 10ee7b: 8b 4d 18 mov 0x18(%ebp),%ecx <== NOT EXECUTED 10ee7e: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ee80: 0f 84 92 00 00 00 je 10ef18 <== NOT EXECUTED if ( (is_global = _Attributes_Is_global( attribute_set ) ) && !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) 10ee86: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10ee89: 85 d2 test %edx,%edx <== NOT EXECUTED 10ee8b: 74 13 je 10eea0 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 10ee8d: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10ee90: 85 c0 test %eax,%eax <== NOT EXECUTED 10ee92: 75 24 jne 10eeb8 <== NOT EXECUTED 10ee94: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10ee99: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ee9c: 5b pop %ebx <== NOT EXECUTED 10ee9d: 5e pop %esi <== NOT EXECUTED 10ee9e: c9 leave <== NOT EXECUTED 10ee9f: c3 ret <== NOT EXECUTED if ( (is_global = _Attributes_Is_global( attribute_set ) ) && !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) 10eea0: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10eea5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10eea8: 5b pop %ebx <== NOT EXECUTED 10eea9: 5e pop %esi <== NOT EXECUTED 10eeaa: c9 leave <== NOT EXECUTED 10eeab: c3 ret <== NOT EXECUTED CORE_message_queue_Attributes the_msgq_attributes; #if defined(RTEMS_MULTIPROCESSING) bool is_global; #endif if ( !rtems_is_name_valid( name ) ) 10eeac: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10eeb1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10eeb4: 5b pop %ebx <== NOT EXECUTED 10eeb5: 5e pop %esi <== NOT EXECUTED 10eeb6: c9 leave <== NOT EXECUTED 10eeb7: c3 ret <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10eeb8: a1 f8 1e 16 00 mov 0x161ef8,%eax <== NOT EXECUTED 10eebd: 40 inc %eax <== NOT EXECUTED 10eebe: a3 f8 1e 16 00 mov %eax,0x161ef8 <== NOT EXECUTED #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); 10eec3: e8 e8 71 01 00 call 1260b0 <_Message_queue_Allocate> <== NOT EXECUTED 10eec8: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !the_message_queue ) { 10eeca: 85 c0 test %eax,%eax <== NOT EXECUTED 10eecc: 74 7a je 10ef48 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_message_queue->attribute_set = attribute_set; 10eece: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10eed1: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED if (_Attributes_Is_priority( attribute_set ) ) the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 10eed4: a8 04 test $0x4,%al <== NOT EXECUTED 10eed6: 0f 95 c0 setne %al <== NOT EXECUTED 10eed9: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10eedc: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 10eedf: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10eee2: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10eee5: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10eee8: 50 push %eax <== NOT EXECUTED 10eee9: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 10eeec: 50 push %eax <== NOT EXECUTED 10eeed: e8 72 0f 00 00 call 10fe64 <_CORE_message_queue_Initialize> <== NOT EXECUTED 10eef2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eef5: 84 c0 test %al,%al <== NOT EXECUTED 10eef7: 75 2b jne 10ef24 <== NOT EXECUTED * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, 10eef9: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10eefc: 53 push %ebx <== NOT EXECUTED 10eefd: 68 40 2a 16 00 push $0x162a40 <== NOT EXECUTED 10ef02: e8 49 1d 00 00 call 110c50 <_Objects_Free> <== NOT EXECUTED _Objects_MP_Close( &_Message_queue_Information, the_message_queue->Object.id); #endif _Message_queue_Free( the_message_queue ); _Thread_Enable_dispatch(); 10ef07: e8 6c 28 00 00 call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ef0c: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 10ef11: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ef14: eb 83 jmp 10ee99 <== NOT EXECUTED 10ef16: 66 90 xchg %ax,%ax <== NOT EXECUTED #endif if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 10ef18: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10ef1d: e9 77 ff ff ff jmp 10ee99 <== NOT EXECUTED 10ef22: 66 90 xchg %ax,%ax <== NOT EXECUTED 10ef24: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10ef27: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10ef2a: a1 5c 2a 16 00 mov 0x162a5c,%eax <== NOT EXECUTED 10ef2f: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10ef32: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 10ef35: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10ef38: 89 08 mov %ecx,(%eax) <== NOT EXECUTED name, 0 ); #endif _Thread_Enable_dispatch(); 10ef3a: e8 39 28 00 00 call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ef3f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ef41: e9 53 ff ff ff jmp 10ee99 <== NOT EXECUTED 10ef46: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); if ( !the_message_queue ) { _Thread_Enable_dispatch(); 10ef48: e8 2b 28 00 00 call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ef4d: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10ef52: e9 42 ff ff ff jmp 10ee99 <== NOT EXECUTED 00115fb8 : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 115fb8: 55 push %ebp <== NOT EXECUTED 115fb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115fbb: 53 push %ebx <== NOT EXECUTED 115fbc: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 115fbf: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 115fc2: 50 push %eax <== NOT EXECUTED 115fc3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 115fc6: 68 20 e7 12 00 push $0x12e720 <== NOT EXECUTED 115fcb: e8 44 a9 ff ff call 110914 <_Objects_Get> <== NOT EXECUTED 115fd0: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 115fd2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115fd5: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 115fd8: 85 c9 test %ecx,%ecx <== NOT EXECUTED 115fda: 75 3c jne 116018 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, 115fdc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 115fdf: 50 push %eax <== NOT EXECUTED 115fe0: 68 20 e7 12 00 push $0x12e720 <== NOT EXECUTED 115fe5: e8 b6 a4 ff ff call 1104a0 <_Objects_Close> <== NOT EXECUTED &the_message_queue->Object ); _CORE_message_queue_Close( 115fea: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 115fed: 6a 05 push $0x5 <== NOT EXECUTED 115fef: 6a 00 push $0x0 <== NOT EXECUTED 115ff1: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 115ff4: 50 push %eax <== NOT EXECUTED 115ff5: e8 ce 04 00 00 call 1164c8 <_CORE_message_queue_Close> <== NOT EXECUTED * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, 115ffa: 58 pop %eax <== NOT EXECUTED 115ffb: 5a pop %edx <== NOT EXECUTED 115ffc: 53 push %ebx <== NOT EXECUTED 115ffd: 68 20 e7 12 00 push $0x12e720 <== NOT EXECUTED 116002: e8 d9 a7 ff ff call 1107e0 <_Objects_Free> <== NOT EXECUTED 0, /* Not used */ 0 ); } #endif _Thread_Enable_dispatch(); 116007: e8 4c b1 ff ff call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 11600c: 31 c0 xor %eax,%eax <== NOT EXECUTED 11600e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116011: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 116014: c9 leave <== NOT EXECUTED 116015: c3 ret <== NOT EXECUTED 116016: 66 90 xchg %ax,%ax <== NOT EXECUTED { register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 116018: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11601d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 116020: c9 leave <== NOT EXECUTED 116021: c3 ret <== NOT EXECUTED 00112508 : rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) { 112508: 55 push %ebp <== NOT EXECUTED 112509: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11250b: 53 push %ebx <== NOT EXECUTED 11250c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 11250f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 112512: 85 db test %ebx,%ebx <== NOT EXECUTED 112514: 74 46 je 11255c <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 112516: 51 push %ecx <== NOT EXECUTED 112517: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 11251a: 50 push %eax <== NOT EXECUTED 11251b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11251e: 68 60 77 13 00 push $0x137760 <== NOT EXECUTED 112523: e8 18 47 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 112528: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11252b: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 11252e: 85 d2 test %edx,%edx <== NOT EXECUTED 112530: 74 0a je 11253c <== NOT EXECUTED 112532: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112537: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11253a: c9 leave <== NOT EXECUTED 11253b: c3 ret <== NOT EXECUTED the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *count = _CORE_message_queue_Flush( &the_message_queue->message_queue ); 11253c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11253f: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 112542: 50 push %eax <== NOT EXECUTED 112543: e8 0c 31 00 00 call 115654 <_CORE_message_queue_Flush> <== NOT EXECUTED 112548: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 11254a: e8 35 4f 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 11254f: 31 c0 xor %eax,%eax <== NOT EXECUTED 112551: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112554: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112557: c9 leave <== NOT EXECUTED 112558: c3 ret <== NOT EXECUTED 112559: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 11255c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112561: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112564: c9 leave <== NOT EXECUTED 112565: c3 ret <== NOT EXECUTED 00112568 : rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) { 112568: 55 push %ebp <== NOT EXECUTED 112569: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11256b: 53 push %ebx <== NOT EXECUTED 11256c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 11256f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 112572: 85 db test %ebx,%ebx <== NOT EXECUTED 112574: 74 3a je 1125b0 <== NOT EXECUTED 112576: 51 push %ecx <== NOT EXECUTED 112577: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 11257a: 50 push %eax <== NOT EXECUTED 11257b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11257e: 68 60 77 13 00 push $0x137760 <== NOT EXECUTED 112583: e8 b8 46 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 112588: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11258b: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 11258e: 85 d2 test %edx,%edx <== NOT EXECUTED 112590: 74 0a je 11259c <== NOT EXECUTED 112592: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112597: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11259a: c9 leave <== NOT EXECUTED 11259b: c3 ret <== NOT EXECUTED the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *count = the_message_queue->message_queue.number_of_pending_messages; 11259c: 8b 40 5c mov 0x5c(%eax),%eax <== NOT EXECUTED 11259f: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 1125a1: e8 de 4e 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 1125a6: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1125a8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1125ab: c9 leave <== NOT EXECUTED 1125ac: c3 ret <== NOT EXECUTED 1125ad: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 1125b0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1125b5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1125b8: c9 leave <== NOT EXECUTED 1125b9: c3 ret <== NOT EXECUTED 0010a07c : rtems_status_code rtems_message_queue_ident( rtems_name name, uint32_t node, Objects_Id *id ) { 10a07c: 55 push %ebp <== NOT EXECUTED 10a07d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a07f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 10a082: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a085: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a088: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a08b: 68 a0 01 12 00 push $0x1201a0 <== NOT EXECUTED 10a090: e8 cb 1b 00 00 call 10bc60 <_Objects_Name_to_id_u32> <== NOT EXECUTED 10a095: 8b 04 85 d4 90 11 00 mov 0x1190d4(,%eax,4),%eax <== NOT EXECUTED node, id ); return _Status_Object_name_errors_to_status[ status ]; } 10a09c: c9 leave <== NOT EXECUTED 10a09d: c3 ret <== NOT EXECUTED 00116024 : void *buffer, size_t *size, rtems_option option_set, rtems_interval timeout ) { 116024: 55 push %ebp <== NOT EXECUTED 116025: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116027: 57 push %edi <== NOT EXECUTED 116028: 56 push %esi <== NOT EXECUTED 116029: 53 push %ebx <== NOT EXECUTED 11602a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 11602d: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 116030: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 116033: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; bool wait; if ( !buffer ) 116036: 85 ff test %edi,%edi <== NOT EXECUTED 116038: 74 6e je 1160a8 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !size ) 11603a: 85 f6 test %esi,%esi <== NOT EXECUTED 11603c: 74 6a je 1160a8 <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 11603e: 51 push %ecx <== NOT EXECUTED 11603f: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 116042: 50 push %eax <== NOT EXECUTED 116043: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 116046: 68 20 e7 12 00 push $0x12e720 <== NOT EXECUTED 11604b: e8 c4 a8 ff ff call 110914 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 116050: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116053: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 116056: 85 d2 test %edx,%edx <== NOT EXECUTED 116058: 75 3e jne 116098 <== NOT EXECUTED if ( _Options_Is_no_wait( option_set ) ) wait = false; else wait = true; _CORE_message_queue_Seize( 11605a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11605d: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 116060: 83 f3 01 xor $0x1,%ebx <== NOT EXECUTED 116063: 83 e3 01 and $0x1,%ebx <== NOT EXECUTED 116066: 53 push %ebx <== NOT EXECUTED 116067: 56 push %esi <== NOT EXECUTED 116068: 57 push %edi <== NOT EXECUTED 116069: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 11606c: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 11606f: 50 push %eax <== NOT EXECUTED 116070: e8 b7 05 00 00 call 11662c <_CORE_message_queue_Seize> <== NOT EXECUTED buffer, size, wait, timeout ); _Thread_Enable_dispatch(); 116075: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 116078: e8 db b0 ff ff call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code( 11607d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116080: a1 7c dd 12 00 mov 0x12dd7c,%eax <== NOT EXECUTED 116085: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 116088: e8 87 8b ff ff call 10ec14 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 11608d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 116090: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116093: 5b pop %ebx <== NOT EXECUTED 116094: 5e pop %esi <== NOT EXECUTED 116095: 5f pop %edi <== NOT EXECUTED 116096: c9 leave <== NOT EXECUTED 116097: c3 ret <== NOT EXECUTED if ( !size ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 116098: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11609d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1160a0: 5b pop %ebx <== NOT EXECUTED 1160a1: 5e pop %esi <== NOT EXECUTED 1160a2: 5f pop %edi <== NOT EXECUTED 1160a3: c9 leave <== NOT EXECUTED 1160a4: c3 ret <== NOT EXECUTED 1160a5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 1160a8: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1160ad: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1160b0: 5b pop %ebx <== NOT EXECUTED 1160b1: 5e pop %esi <== NOT EXECUTED 1160b2: 5f pop %edi <== NOT EXECUTED 1160b3: c9 leave <== NOT EXECUTED 1160b4: c3 ret <== NOT EXECUTED 0010a0a0 : rtems_status_code rtems_message_queue_send( Objects_Id id, const void *buffer, size_t size ) { 10a0a0: 55 push %ebp <== NOT EXECUTED 10a0a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a0a3: 56 push %esi <== NOT EXECUTED 10a0a4: 53 push %ebx <== NOT EXECUTED 10a0a5: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10a0a8: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10a0ab: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 10a0ae: 85 db test %ebx,%ebx <== NOT EXECUTED 10a0b0: 74 5e je 10a110 <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 10a0b2: 51 push %ecx <== NOT EXECUTED 10a0b3: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10a0b6: 50 push %eax <== NOT EXECUTED 10a0b7: 56 push %esi <== NOT EXECUTED 10a0b8: 68 a0 01 12 00 push $0x1201a0 <== NOT EXECUTED 10a0bd: e8 46 1a 00 00 call 10bb08 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 10a0c2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0c5: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 10a0c8: 85 d2 test %edx,%edx <== NOT EXECUTED 10a0ca: 74 0c je 10a0d8 <== NOT EXECUTED 10a0cc: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a0d1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a0d4: 5b pop %ebx <== NOT EXECUTED 10a0d5: 5e pop %esi <== NOT EXECUTED 10a0d6: c9 leave <== NOT EXECUTED 10a0d7: c3 ret <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory for * the heap 10a0d8: 6a 00 push $0x0 <== NOT EXECUTED 10a0da: 6a 00 push $0x0 <== NOT EXECUTED 10a0dc: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 10a0e1: 6a 00 push $0x0 <== NOT EXECUTED 10a0e3: 56 push %esi <== NOT EXECUTED 10a0e4: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a0e7: 53 push %ebx <== NOT EXECUTED 10a0e8: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 10a0eb: 50 push %eax <== NOT EXECUTED 10a0ec: e8 37 0d 00 00 call 10ae28 <_CORE_message_queue_Submit> <== NOT EXECUTED 10a0f1: 89 c3 mov %eax,%ebx <== NOT EXECUTED MESSAGE_QUEUE_MP_HANDLER, FALSE, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 10a0f3: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a0f6: e8 51 22 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED /* * 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); 10a0fb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a0fe: 53 push %ebx <== NOT EXECUTED 10a0ff: e8 18 00 00 00 call 10a11c <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 10a104: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a107: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a10a: 5b pop %ebx <== NOT EXECUTED 10a10b: 5e pop %esi <== NOT EXECUTED 10a10c: c9 leave <== NOT EXECUTED 10a10d: c3 ret <== NOT EXECUTED 10a10e: 66 90 xchg %ax,%ax <== NOT EXECUTED { register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 10a110: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a115: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a118: 5b pop %ebx <== NOT EXECUTED 10a119: 5e pop %esi <== NOT EXECUTED 10a11a: c9 leave <== NOT EXECUTED 10a11b: c3 ret <== NOT EXECUTED 00112700 : rtems_status_code rtems_message_queue_urgent( Objects_Id id, const void *buffer, size_t size ) { 112700: 55 push %ebp <== NOT EXECUTED 112701: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112703: 56 push %esi <== NOT EXECUTED 112704: 53 push %ebx <== NOT EXECUTED 112705: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 112708: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 11270b: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 11270e: 85 db test %ebx,%ebx <== NOT EXECUTED 112710: 74 5e je 112770 <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, 112712: 51 push %ecx <== NOT EXECUTED 112713: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 112716: 50 push %eax <== NOT EXECUTED 112717: 56 push %esi <== NOT EXECUTED 112718: 68 60 77 13 00 push $0x137760 <== NOT EXECUTED 11271d: e8 1e 45 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 112722: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112725: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 112728: 85 d2 test %edx,%edx <== NOT EXECUTED 11272a: 74 0c je 112738 <== NOT EXECUTED 11272c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112731: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 112734: 5b pop %ebx <== NOT EXECUTED 112735: 5e pop %esi <== NOT EXECUTED 112736: c9 leave <== NOT EXECUTED 112737: c3 ret <== NOT EXECUTED size_t size 112738: 6a 00 push $0x0 <== NOT EXECUTED 11273a: 6a 00 push $0x0 <== NOT EXECUTED 11273c: 68 00 00 00 80 push $0x80000000 <== NOT EXECUTED 112741: 6a 00 push $0x0 <== NOT EXECUTED 112743: 56 push %esi <== NOT EXECUTED 112744: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 112747: 53 push %ebx <== NOT EXECUTED 112748: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 11274b: 50 push %eax <== NOT EXECUTED 11274c: e8 4b 31 00 00 call 11589c <_CORE_message_queue_Submit> <== NOT EXECUTED 112751: 89 c3 mov %eax,%ebx <== NOT EXECUTED id, MESSAGE_QUEUE_MP_HANDLER, FALSE, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 112753: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 112756: e8 29 4d 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED /* * 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); 11275b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11275e: 53 push %ebx <== NOT EXECUTED 11275f: e8 8c ff ff ff call 1126f0 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 112764: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112767: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11276a: 5b pop %ebx <== NOT EXECUTED 11276b: 5e pop %esi <== NOT EXECUTED 11276c: c9 leave <== NOT EXECUTED 11276d: c3 ret <== NOT EXECUTED 11276e: 66 90 xchg %ax,%ax <== NOT EXECUTED { register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 112770: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112775: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 112778: 5b pop %ebx <== NOT EXECUTED 112779: 5e pop %esi <== NOT EXECUTED 11277a: c9 leave <== NOT EXECUTED 11277b: c3 ret <== NOT EXECUTED 0010a5dc : #include int rtems_object_api_maximum_class( uint32_t api ) { 10a5dc: 55 push %ebp <== NOT EXECUTED 10a5dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_API_maximum_class(api); } 10a5df: c9 leave <== NOT EXECUTED int rtems_object_api_maximum_class( uint32_t api ) { return _Objects_API_maximum_class(api); 10a5e0: e9 f7 15 00 00 jmp 10bbdc <_Objects_API_maximum_class> <== NOT EXECUTED 0010a5e8 : #include uint32_t rtems_object_api_minimum_class( uint32_t api ) { 10a5e8: 55 push %ebp <== NOT EXECUTED 10a5e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED /** * This function sets @a *size to the size of the block of user memory * which begins at @a starting_address. The size returned in @a *size could * be greater than the size requested for allocation. * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. 10a5eb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a5ee: 48 dec %eax <== NOT EXECUTED 10a5ef: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10a5f2: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10a5f4: 83 e0 02 and $0x2,%eax <== NOT EXECUTED 10a5f7: 48 dec %eax <== NOT EXECUTED if ( _Objects_Is_api_valid( api ) ) return 1; return -1; } 10a5f8: c9 leave <== NOT EXECUTED 10a5f9: c3 ret <== NOT EXECUTED 0010a5fc : const char *rtems_object_get_api_class_name( uint32_t the_api, uint32_t the_class ) { 10a5fc: 55 push %ebp <== NOT EXECUTED 10a5fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a5ff: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a602: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) 10a605: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10a608: 74 36 je 10a640 <== NOT EXECUTED api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) 10a60a: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10a60d: 74 0d je 10a61c <== NOT EXECUTED api_assoc = rtems_object_api_classic_assoc; #ifdef RTEMS_POSIX_API else if ( the_api == OBJECTS_POSIX_API ) 10a60f: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10a612: 74 24 je 10a638 <== NOT EXECUTED 10a614: b8 f0 b9 11 00 mov $0x11b9f0,%eax <== NOT EXECUTED return "BAD API"; class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class ); if ( class_assoc ) return class_assoc->name; return "BAD CLASS"; } 10a619: c9 leave <== NOT EXECUTED 10a61a: c3 ret <== NOT EXECUTED 10a61b: 90 nop <== NOT EXECUTED const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) 10a61c: b8 80 0b 12 00 mov $0x120b80,%eax <== NOT EXECUTED else if ( the_api == OBJECTS_ITRON_API ) api_assoc = rtems_object_api_itron_assoc; #endif else return "BAD API"; class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class ); 10a621: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a624: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a627: 50 push %eax <== NOT EXECUTED 10a628: e8 93 45 00 00 call 10ebc0 <== NOT EXECUTED if ( class_assoc ) 10a62d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a630: 85 c0 test %eax,%eax <== NOT EXECUTED 10a632: 74 14 je 10a648 <== NOT EXECUTED return class_assoc->name; 10a634: 8b 00 mov (%eax),%eax <== NOT EXECUTED return "BAD CLASS"; } 10a636: c9 leave <== NOT EXECUTED 10a637: c3 ret <== NOT EXECUTED if ( the_api == OBJECTS_INTERNAL_API ) api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) api_assoc = rtems_object_api_classic_assoc; #ifdef RTEMS_POSIX_API else if ( the_api == OBJECTS_POSIX_API ) 10a638: b8 00 0c 12 00 mov $0x120c00,%eax <== NOT EXECUTED 10a63d: eb e2 jmp 10a621 <== NOT EXECUTED 10a63f: 90 nop <== NOT EXECUTED ) { const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) 10a640: b8 60 0b 12 00 mov $0x120b60,%eax <== NOT EXECUTED 10a645: eb da jmp 10a621 <== NOT EXECUTED 10a647: 90 nop <== NOT EXECUTED api_assoc = rtems_object_api_itron_assoc; #endif else return "BAD API"; class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class ); if ( class_assoc ) 10a648: b8 f8 b9 11 00 mov $0x11b9f8,%eax <== NOT EXECUTED return class_assoc->name; return "BAD CLASS"; } 10a64d: c9 leave <== NOT EXECUTED 10a64e: c3 ret <== NOT EXECUTED 0010a650 : }; const char *rtems_object_get_api_name( uint32_t api ) { 10a650: 55 push %ebp <== NOT EXECUTED 10a651: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a653: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED const rtems_assoc_t *api_assoc; api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api ); 10a656: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a659: 68 a0 0c 12 00 push $0x120ca0 <== NOT EXECUTED 10a65e: e8 5d 45 00 00 call 10ebc0 <== NOT EXECUTED if ( api_assoc ) 10a663: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a666: 85 c0 test %eax,%eax <== NOT EXECUTED 10a668: 74 06 je 10a670 <== NOT EXECUTED return api_assoc->name; 10a66a: 8b 00 mov (%eax),%eax <== NOT EXECUTED return "BAD CLASS"; } 10a66c: c9 leave <== NOT EXECUTED 10a66d: c3 ret <== NOT EXECUTED 10a66e: 66 90 xchg %ax,%ax <== NOT EXECUTED ) { const rtems_assoc_t *api_assoc; api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api ); if ( api_assoc ) 10a670: b8 f8 b9 11 00 mov $0x11b9f8,%eax <== NOT EXECUTED return api_assoc->name; return "BAD CLASS"; } 10a675: c9 leave <== NOT EXECUTED 10a676: c3 ret <== NOT EXECUTED 0010b788 : rtems_status_code rtems_object_get_class_information( uint32_t the_api, uint32_t the_class, rtems_object_api_class_information *info ) { 10b788: 55 push %ebp <== NOT EXECUTED 10b789: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b78b: 56 push %esi <== NOT EXECUTED 10b78c: 53 push %ebx <== NOT EXECUTED 10b78d: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED uint32_t i; /* * Validate parameters and look up information structure. */ if ( !info ) 10b790: 85 f6 test %esi,%esi <== NOT EXECUTED 10b792: 74 58 je 10b7ec <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 10b794: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b797: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b79a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b79d: e8 c6 1a 00 00 call 10d268 <_Objects_Get_information> <== NOT EXECUTED 10b7a2: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !obj_info ) 10b7a4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b7a7: 85 c0 test %eax,%eax <== NOT EXECUTED 10b7a9: 74 4d je 10b7f8 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 10b7ab: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10b7ae: 89 06 mov %eax,(%esi) <== NOT EXECUTED info->maximum_id = obj_info->maximum_id; 10b7b0: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10b7b3: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED info->auto_extend = obj_info->auto_extend; 10b7b6: 8a 42 12 mov 0x12(%edx),%al <== NOT EXECUTED 10b7b9: 88 46 0c mov %al,0xc(%esi) <== NOT EXECUTED info->maximum = obj_info->maximum; 10b7bc: 0f b7 42 10 movzwl 0x10(%edx),%eax <== NOT EXECUTED 10b7c0: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10b7c3: 85 c0 test %eax,%eax <== NOT EXECUTED 10b7c5: 74 3d je 10b804 <== NOT EXECUTED 10b7c7: 8b 5a 1c mov 0x1c(%edx),%ebx <== NOT EXECUTED 10b7ca: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10b7cc: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10b7d1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !obj_info->local_table[i] ) unallocated++; 10b7d4: 83 3c 93 01 cmpl $0x1,(%ebx,%edx,4) <== NOT EXECUTED 10b7d8: 83 d1 00 adc $0x0,%ecx <== NOT EXECUTED info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10b7db: 42 inc %edx <== NOT EXECUTED 10b7dc: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10b7de: 73 f4 jae 10b7d4 <== NOT EXECUTED if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 10b7e0: 89 4e 10 mov %ecx,0x10(%esi) <== NOT EXECUTED 10b7e3: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10b7e5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b7e8: 5b pop %ebx <== NOT EXECUTED 10b7e9: 5e pop %esi <== NOT EXECUTED 10b7ea: c9 leave <== NOT EXECUTED 10b7eb: c3 ret <== NOT EXECUTED uint32_t i; /* * Validate parameters and look up information structure. */ if ( !info ) 10b7ec: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 10b7f1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b7f4: 5b pop %ebx <== NOT EXECUTED 10b7f5: 5e pop %esi <== NOT EXECUTED 10b7f6: c9 leave <== NOT EXECUTED 10b7f7: c3 ret <== NOT EXECUTED */ if ( !info ) return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); if ( !obj_info ) 10b7f8: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 10b7fd: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b800: 5b pop %ebx <== NOT EXECUTED 10b801: 5e pop %esi <== NOT EXECUTED 10b802: c9 leave <== NOT EXECUTED 10b803: c3 ret <== NOT EXECUTED info->minimum_id = obj_info->minimum_id; info->maximum_id = obj_info->maximum_id; info->auto_extend = obj_info->auto_extend; info->maximum = obj_info->maximum; for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10b804: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10b806: eb d8 jmp 10b7e0 <== NOT EXECUTED 0010b008 : rtems_status_code rtems_object_get_classic_name( rtems_id id, rtems_name *name ) { 10b008: 55 push %ebp <== NOT EXECUTED 10b009: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b00b: 53 push %ebx <== NOT EXECUTED 10b00c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10b00f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) 10b012: 85 db test %ebx,%ebx <== NOT EXECUTED 10b014: 74 26 je 10b03c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; status = _Objects_Id_to_name( id, &name_u ); 10b016: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b019: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10b01c: 50 push %eax <== NOT EXECUTED 10b01d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b020: e8 77 1b 00 00 call 10cb9c <_Objects_Id_to_name> <== NOT EXECUTED *name = name_u.name_u32; 10b025: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10b028: 89 13 mov %edx,(%ebx) <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; 10b02a: 8b 04 85 74 c4 11 00 mov 0x11c474(,%eax,4),%eax <== NOT EXECUTED 10b031: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b034: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b037: c9 leave <== NOT EXECUTED 10b038: c3 ret <== NOT EXECUTED 10b039: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) 10b03c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED status = _Objects_Id_to_name( id, &name_u ); *name = name_u.name_u32; return _Status_Object_name_errors_to_status[ status ]; } 10b041: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b044: c9 leave <== NOT EXECUTED 10b045: c3 ret <== NOT EXECUTED 0011612c : char *rtems_object_get_name( Objects_Id id, size_t length, char *name ) { 11612c: 55 push %ebp <== NOT EXECUTED 11612d: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_Get_name_as_string( id, length, name ); } 11612f: c9 leave <== NOT EXECUTED Objects_Id id, size_t length, char *name ) { return _Objects_Get_name_as_string( id, length, name ); 116130: e9 9f 09 00 00 jmp 116ad4 <_Objects_Get_name_as_string> <== NOT EXECUTED 0010b814 : #include #include #undef rtems_object_id_api_maximum uint32_t rtems_object_id_api_maximum(void) { 10b814: 55 push %ebp <== NOT EXECUTED 10b815: 89 e5 mov %esp,%ebp <== NOT EXECUTED return OBJECTS_ITRON_API; } 10b817: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10b81c: c9 leave <== NOT EXECUTED 10b81d: c3 ret <== NOT EXECUTED 0010b820 : #include #include #undef rtems_object_id_api_minimum uint32_t rtems_object_id_api_minimum(void) { 10b820: 55 push %ebp <== NOT EXECUTED 10b821: 89 e5 mov %esp,%ebp <== NOT EXECUTED return OBJECTS_INTERNAL_API; } 10b823: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10b828: c9 leave <== NOT EXECUTED 10b829: c3 ret <== NOT EXECUTED 0010b82c : #undef rtems_object_id_get_api uint32_t rtems_object_id_get_api( rtems_id id ) { 10b82c: 55 push %ebp <== NOT EXECUTED 10b82d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b82f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b832: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10b835: 83 e0 07 and $0x7,%eax <== NOT EXECUTED return _Objects_Get_API( id ); } 10b838: c9 leave <== NOT EXECUTED 10b839: c3 ret <== NOT EXECUTED 0010b83c : #undef rtems_object_id_get_class uint32_t rtems_object_id_get_class( rtems_id id ) { 10b83c: 55 push %ebp <== NOT EXECUTED 10b83d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b83f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b842: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED return _Objects_Get_class( id ); } 10b845: c9 leave <== NOT EXECUTED 10b846: c3 ret <== NOT EXECUTED 0010b848 : #undef rtems_object_id_get_index uint32_t rtems_object_id_get_index( rtems_id id ) { 10b848: 55 push %ebp <== NOT EXECUTED 10b849: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b84b: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED return _Objects_Get_index( id ); } 10b84f: c9 leave <== NOT EXECUTED 10b850: c3 ret <== NOT EXECUTED 0010b854 : #undef rtems_object_id_get_node uint32_t rtems_object_id_get_node( rtems_id id ) { 10b854: 55 push %ebp <== NOT EXECUTED 10b855: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b857: 0f b6 45 0a movzbl 0xa(%ebp),%eax <== NOT EXECUTED return _Objects_Get_node( id ); } 10b85b: c9 leave <== NOT EXECUTED 10b85c: c3 ret <== NOT EXECUTED 0010a684 : */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) { 10a684: 55 push %ebp <== NOT EXECUTED 10a685: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a687: 57 push %edi <== NOT EXECUTED 10a688: 56 push %esi <== NOT EXECUTED 10a689: 53 push %ebx <== NOT EXECUTED 10a68a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10a68d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a690: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 10a693: 85 ff test %edi,%edi <== NOT EXECUTED 10a695: 74 65 je 10a6fc <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10a697: 85 c0 test %eax,%eax <== NOT EXECUTED 10a699: 74 45 je 10a6e0 <== NOT EXECUTED 10a69b: 89 c3 mov %eax,%ebx <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 10a69d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a6a0: 53 push %ebx <== NOT EXECUTED 10a6a1: e8 32 19 00 00 call 10bfd8 <_Objects_Get_information_id> <== NOT EXECUTED 10a6a6: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !information ) 10a6a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a6ab: 85 c0 test %eax,%eax <== NOT EXECUTED 10a6ad: 74 3d je 10a6ec <== NOT EXECUTED return RTEMS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &location ); 10a6af: 50 push %eax <== NOT EXECUTED 10a6b0: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10a6b3: 50 push %eax <== NOT EXECUTED 10a6b4: 53 push %ebx <== NOT EXECUTED 10a6b5: 56 push %esi <== NOT EXECUTED 10a6b6: e8 dd 1a 00 00 call 10c198 <_Objects_Get> <== NOT EXECUTED switch ( location ) { 10a6bb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a6be: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10a6c1: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a6c3: 75 27 jne 10a6ec <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); 10a6c5: 52 push %edx <== NOT EXECUTED 10a6c6: 57 push %edi <== NOT EXECUTED 10a6c7: 50 push %eax <== NOT EXECUTED 10a6c8: 56 push %esi <== NOT EXECUTED 10a6c9: e8 ae 1c 00 00 call 10c37c <_Objects_Set_name> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a6ce: e8 fd 23 00 00 call 10cad0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a6d3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a6d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a6d8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a6db: 5b pop %ebx <== NOT EXECUTED 10a6dc: 5e pop %esi <== NOT EXECUTED 10a6dd: 5f pop %edi <== NOT EXECUTED 10a6de: c9 leave <== NOT EXECUTED 10a6df: c3 ret <== NOT EXECUTED Objects_Id tmpId; if ( !name ) return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10a6e0: a1 fc 2f 12 00 mov 0x122ffc,%eax <== NOT EXECUTED 10a6e5: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED 10a6e8: eb b3 jmp 10a69d <== NOT EXECUTED 10a6ea: 66 90 xchg %ax,%ax <== NOT EXECUTED switch ( location ) { case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 10a6ec: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a6f1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a6f4: 5b pop %ebx <== NOT EXECUTED 10a6f5: 5e pop %esi <== NOT EXECUTED 10a6f6: 5f pop %edi <== NOT EXECUTED 10a6f7: c9 leave <== NOT EXECUTED 10a6f8: c3 ret <== NOT EXECUTED 10a6f9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 10a6fc: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a701: eb d5 jmp 10a6d8 <== NOT EXECUTED 0010b878 : void rtems_panic( const char *printf_format, ... ) { 10b878: 55 push %ebp <== NOT EXECUTED 10b879: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b87b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b87e: 8d 4d 0c lea 0xc(%ebp),%ecx <== NOT EXECUTED va_list arglist; va_start(arglist, printf_format); (void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist); 10b881: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b884: b8 00 00 00 20 mov $0x20000000,%eax <== NOT EXECUTED 10b889: e8 42 fe ff ff call 10b6d0 <== NOT EXECUTED va_end(arglist); } 10b88e: c9 leave <== NOT EXECUTED 10b88f: c3 ret <== NOT EXECUTED 0011277c : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) { 11277c: 55 push %ebp <== NOT EXECUTED 11277d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11277f: 56 push %esi <== NOT EXECUTED 112780: 53 push %ebx <== NOT EXECUTED 112781: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 112784: 85 f6 test %esi,%esi <== NOT EXECUTED 112786: 74 48 je 1127d0 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !starting_address ) 112788: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 11278b: 85 db test %ebx,%ebx <== NOT EXECUTED 11278d: 74 27 je 1127b6 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !id ) 11278f: 8b 4d 1c mov 0x1c(%ebp),%ecx <== NOT EXECUTED 112792: 85 c9 test %ecx,%ecx <== NOT EXECUTED 112794: 74 20 je 1127b6 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 112796: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 112799: 85 d2 test %edx,%edx <== NOT EXECUTED 11279b: 74 27 je 1127c4 <== NOT EXECUTED 11279d: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1127a0: 85 c0 test %eax,%eax <== NOT EXECUTED 1127a2: 74 20 je 1127c4 <== NOT EXECUTED 1127a4: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1127a7: 39 45 10 cmp %eax,0x10(%ebp) <== NOT EXECUTED 1127aa: 72 18 jb 1127c4 <== NOT EXECUTED 1127ac: a8 03 test $0x3,%al <== NOT EXECUTED 1127ae: 75 14 jne 1127c4 <== NOT EXECUTED !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 1127b0: f6 45 0c 03 testb $0x3,0xc(%ebp) <== NOT EXECUTED 1127b4: 74 26 je 1127dc <== NOT EXECUTED 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 1127b6: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } 1127bb: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1127be: 5b pop %ebx <== NOT EXECUTED 1127bf: 5e pop %esi <== NOT EXECUTED 1127c0: c9 leave <== NOT EXECUTED 1127c1: c3 ret <== NOT EXECUTED 1127c2: 66 90 xchg %ax,%ax <== NOT EXECUTED 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 1127c4: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED } 1127c9: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1127cc: 5b pop %ebx <== NOT EXECUTED 1127cd: 5e pop %esi <== NOT EXECUTED 1127ce: c9 leave <== NOT EXECUTED 1127cf: c3 ret <== NOT EXECUTED Objects_Id *id ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 1127d0: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1127d5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1127d8: 5b pop %ebx <== NOT EXECUTED 1127d9: 5e pop %esi <== NOT EXECUTED 1127da: c9 leave <== NOT EXECUTED 1127db: c3 ret <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1127dc: a1 78 6d 13 00 mov 0x136d78,%eax <== NOT EXECUTED 1127e1: 40 inc %eax <== NOT EXECUTED 1127e2: a3 78 6d 13 00 mov %eax,0x136d78 <== NOT EXECUTED * Returns TRUE if the @a starting_address is in the heap, and FALSE * otherwise. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the user block * to obtain the size of 1127e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1127ea: 68 80 6b 13 00 push $0x136b80 <== NOT EXECUTED 1127ef: e8 18 3f 00 00 call 11670c <_Objects_Allocate> <== NOT EXECUTED 1127f4: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 1127f6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1127f9: 85 c0 test %eax,%eax <== NOT EXECUTED 1127fb: 74 5f je 11285c <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 1127fd: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 112800: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED the_partition->length = length; 112803: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 112806: 89 43 14 mov %eax,0x14(%ebx) <== NOT EXECUTED the_partition->buffer_size = buffer_size; 112809: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 11280c: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED the_partition->attribute_set = attribute_set; 11280f: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 112812: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED the_partition->number_of_used_blocks = 0; 112815: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED _Chain_Initialize( &the_partition->Memory, starting_address, 11281c: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 11281f: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 112822: 31 d2 xor %edx,%edx <== NOT EXECUTED 112824: f7 75 14 divl 0x14(%ebp) <== NOT EXECUTED 112827: 50 push %eax <== NOT EXECUTED 112828: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11282b: 8d 43 24 lea 0x24(%ebx),%eax <== NOT EXECUTED 11282e: 50 push %eax <== NOT EXECUTED 11282f: e8 1c 2d 00 00 call 115550 <_Chain_Initialize> <== NOT EXECUTED 112834: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 112837: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 11283a: a1 9c 6b 13 00 mov 0x136b9c,%eax <== NOT EXECUTED 11283f: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 112842: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 112845: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 112848: 89 08 mov %ecx,(%eax) <== NOT EXECUTED name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 11284a: e8 35 4c 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 11284f: 31 c0 xor %eax,%eax <== NOT EXECUTED 112851: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112854: e9 70 ff ff ff jmp 1127c9 <== NOT EXECUTED 112859: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { _Thread_Enable_dispatch(); 11285c: e8 23 4c 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 112861: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 112866: e9 5e ff ff ff jmp 1127c9 <== NOT EXECUTED 0011286c : */ rtems_status_code rtems_partition_delete( Objects_Id id ) { 11286c: 55 push %ebp <== NOT EXECUTED 11286d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11286f: 53 push %ebx <== NOT EXECUTED 112870: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED ); /** * This routine returns the block of memory which begins * at @a starting_address to @a the_heap. Any coalescing which is * possible with the freeing of this routine is performed. 112873: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112876: 50 push %eax <== NOT EXECUTED 112877: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11287a: 68 80 6b 13 00 push $0x136b80 <== NOT EXECUTED 11287f: e8 bc 43 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED 112884: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 112886: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112889: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 11288c: 85 c0 test %eax,%eax <== NOT EXECUTED 11288e: 74 0c je 11289c <== NOT EXECUTED 112890: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112895: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112898: c9 leave <== NOT EXECUTED 112899: c3 ret <== NOT EXECUTED 11289a: 66 90 xchg %ax,%ax <== NOT EXECUTED the_partition = _Partition_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( the_partition->number_of_used_blocks == 0 ) { 11289c: 8b 4b 20 mov 0x20(%ebx),%ecx <== NOT EXECUTED 11289f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1128a1: 74 11 je 1128b4 <== NOT EXECUTED #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 1128a3: e8 dc 4b 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 1128a8: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1128ad: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1128b0: c9 leave <== NOT EXECUTED 1128b1: c3 ret <== NOT EXECUTED 1128b2: 66 90 xchg %ax,%ax <== NOT EXECUTED the_partition = _Partition_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( the_partition->number_of_used_blocks == 0 ) { _Objects_Close( &_Partition_Information, &the_partition->Object ); 1128b4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1128b7: 53 push %ebx <== NOT EXECUTED 1128b8: 68 80 6b 13 00 push $0x136b80 <== NOT EXECUTED 1128bd: e8 ca 3e 00 00 call 11678c <_Objects_Close> <== NOT EXECUTED size_t *size ); /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. 1128c2: 58 pop %eax <== NOT EXECUTED 1128c3: 5a pop %edx <== NOT EXECUTED 1128c4: 53 push %ebx <== NOT EXECUTED 1128c5: 68 80 6b 13 00 push $0x136b80 <== NOT EXECUTED 1128ca: e8 fd 41 00 00 call 116acc <_Objects_Free> <== NOT EXECUTED 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 1128cf: e8 b0 4b 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 1128d4: 31 c0 xor %eax,%eax <== NOT EXECUTED 1128d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1128d9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1128dc: c9 leave <== NOT EXECUTED 1128dd: c3 ret <== NOT EXECUTED 001128e0 : rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) { 1128e0: 55 push %ebp <== NOT EXECUTED 1128e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1128e3: 57 push %edi <== NOT EXECUTED 1128e4: 56 push %esi <== NOT EXECUTED 1128e5: 53 push %ebx <== NOT EXECUTED 1128e6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1128e9: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 1128ec: 85 ff test %edi,%edi <== NOT EXECUTED 1128ee: 74 58 je 112948 <== NOT EXECUTED ); /** * This routine returns the block of memory which begins * at @a starting_address to @a the_heap. Any coalescing which is * possible with the freeing of this routine is performed. 1128f0: 52 push %edx <== NOT EXECUTED 1128f1: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1128f4: 50 push %eax <== NOT EXECUTED 1128f5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1128f8: 68 80 6b 13 00 push $0x136b80 <== NOT EXECUTED 1128fd: e8 3e 43 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED 112902: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 112904: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112907: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11290a: 85 c0 test %eax,%eax <== NOT EXECUTED 11290c: 75 2a jne 112938 <== NOT EXECUTED #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of 11290e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112911: 8d 43 24 lea 0x24(%ebx),%eax <== NOT EXECUTED 112914: 50 push %eax <== NOT EXECUTED 112915: e8 0e 2c 00 00 call 115528 <_Chain_Get> <== NOT EXECUTED 11291a: 89 c6 mov %eax,%esi <== NOT EXECUTED case OBJECTS_LOCAL: the_buffer = _Partition_Allocate_buffer( the_partition ); if ( the_buffer ) { 11291c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11291f: 85 c0 test %eax,%eax <== NOT EXECUTED 112921: 74 35 je 112958 <== NOT EXECUTED the_partition->number_of_used_blocks += 1; 112923: ff 43 20 incl 0x20(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 112926: e8 59 4b 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED *buffer = the_buffer; 11292b: 89 37 mov %esi,(%edi) <== NOT EXECUTED 11292d: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11292f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112932: 5b pop %ebx <== NOT EXECUTED 112933: 5e pop %esi <== NOT EXECUTED 112934: 5f pop %edi <== NOT EXECUTED 112935: c9 leave <== NOT EXECUTED 112936: c3 ret <== NOT EXECUTED 112937: 90 nop <== NOT EXECUTED if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 112938: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11293d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112940: 5b pop %ebx <== NOT EXECUTED 112941: 5e pop %esi <== NOT EXECUTED 112942: 5f pop %edi <== NOT EXECUTED 112943: c9 leave <== NOT EXECUTED 112944: c3 ret <== NOT EXECUTED 112945: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 112948: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11294d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112950: 5b pop %ebx <== NOT EXECUTED 112951: 5e pop %esi <== NOT EXECUTED 112952: 5f pop %edi <== NOT EXECUTED 112953: c9 leave <== NOT EXECUTED 112954: c3 ret <== NOT EXECUTED 112955: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_partition->number_of_used_blocks += 1; _Thread_Enable_dispatch(); *buffer = the_buffer; return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 112958: e8 27 4b 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 11295d: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 112962: eb d9 jmp 11293d <== NOT EXECUTED 00112964 : rtems_status_code rtems_partition_ident( rtems_name name, uint32_t node, Objects_Id *id ) { 112964: 55 push %ebp <== NOT EXECUTED 112965: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112967: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( &_Partition_Information, name, node, id ); 11296a: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11296d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 112970: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112973: 68 80 6b 13 00 push $0x136b80 <== NOT EXECUTED 112978: e8 1b 44 00 00 call 116d98 <_Objects_Name_to_id_u32> <== NOT EXECUTED 11297d: 8b 04 85 74 b7 12 00 mov 0x12b774(,%eax,4),%eax <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; } 112984: c9 leave <== NOT EXECUTED 112985: c3 ret <== NOT EXECUTED 00112988 : rtems_status_code rtems_partition_return_buffer( Objects_Id id, void *buffer ) { 112988: 55 push %ebp <== NOT EXECUTED 112989: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11298b: 53 push %ebx <== NOT EXECUTED 11298c: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED ); /** * This routine returns the block of memory which begins * at @a starting_address to @a the_heap. Any coalescing which is * possible with the freeing of this routine is performed. 11298f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112992: 50 push %eax <== NOT EXECUTED 112993: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112996: 68 80 6b 13 00 push $0x136b80 <== NOT EXECUTED 11299b: e8 a0 42 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED 1129a0: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 1129a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1129a5: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 1129a8: 85 c0 test %eax,%eax <== NOT EXECUTED 1129aa: 74 0c je 1129b8 <== NOT EXECUTED 1129ac: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1129b1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1129b4: c9 leave <== NOT EXECUTED 1129b5: c3 ret <== NOT EXECUTED 1129b6: 66 90 xchg %ax,%ax <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); 1129b8: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED 1129bb: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 1129be: 39 55 0c cmp %edx,0xc(%ebp) <== NOT EXECUTED 1129c1: 73 11 jae 1129d4 <== NOT EXECUTED _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 1129c3: e8 bc 4a 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 1129c8: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1129cd: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1129d0: c9 leave <== NOT EXECUTED 1129d1: c3 ret <== NOT EXECUTED 1129d2: 66 90 xchg %ax,%ax <== NOT EXECUTED 1129d4: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED 1129d7: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 1129da: 77 e7 ja 1129c3 <== NOT EXECUTED Heap_Control *the_heap, size_t size ); /** * This function attempts to allocate a memory block of @a size bytes from 1129dc: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1129df: 29 d0 sub %edx,%eax <== NOT EXECUTED 1129e1: 31 d2 xor %edx,%edx <== NOT EXECUTED 1129e3: f7 73 18 divl 0x18(%ebx) <== NOT EXECUTED 1129e6: 85 d2 test %edx,%edx <== NOT EXECUTED 1129e8: 75 d9 jne 1129c3 <== NOT EXECUTED * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( 1129ea: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1129ed: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1129f0: 8d 43 24 lea 0x24(%ebx),%eax <== NOT EXECUTED 1129f3: 50 push %eax <== NOT EXECUTED 1129f4: e8 0b 2b 00 00 call 115504 <_Chain_Append> <== NOT EXECUTED switch ( location ) { case OBJECTS_LOCAL: if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) { _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; 1129f9: ff 4b 20 decl 0x20(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 1129fc: e8 83 4a 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 112a01: 31 c0 xor %eax,%eax <== NOT EXECUTED 112a03: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112a06: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112a09: c9 leave <== NOT EXECUTED 112a0a: c3 ret <== NOT EXECUTED 00111db4 : void *internal_start, void *external_start, uint32_t length, Objects_Id *id ) { 111db4: 55 push %ebp <== NOT EXECUTED 111db5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111db7: 56 push %esi <== NOT EXECUTED 111db8: 53 push %ebx <== NOT EXECUTED 111db9: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name) ) 111dbc: 85 f6 test %esi,%esi <== NOT EXECUTED 111dbe: 74 20 je 111de0 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 111dc0: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 111dc3: 85 c0 test %eax,%eax <== NOT EXECUTED 111dc5: 74 0a je 111dd1 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || 111dc7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 111dca: 0b 45 0c or 0xc(%ebp),%eax <== NOT EXECUTED 111dcd: a8 03 test $0x3,%al <== NOT EXECUTED 111dcf: 74 1b je 111dec <== NOT EXECUTED (Objects_Name) name ); *id = the_port->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 111dd1: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } 111dd6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111dd9: 5b pop %ebx <== NOT EXECUTED 111dda: 5e pop %esi <== NOT EXECUTED 111ddb: c9 leave <== NOT EXECUTED 111ddc: c3 ret <== NOT EXECUTED 111ddd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED Objects_Id *id ) { register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name) ) 111de0: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED ); *id = the_port->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 111de5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111de8: 5b pop %ebx <== NOT EXECUTED 111de9: 5e pop %esi <== NOT EXECUTED 111dea: c9 leave <== NOT EXECUTED 111deb: c3 ret <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 111dec: a1 78 6d 13 00 mov 0x136d78,%eax <== NOT EXECUTED 111df1: 40 inc %eax <== NOT EXECUTED 111df2: a3 78 6d 13 00 mov %eax,0x136d78 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 111df7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111dfa: 68 40 6b 13 00 push $0x136b40 <== NOT EXECUTED 111dff: e8 08 49 00 00 call 11670c <_Objects_Allocate> <== NOT EXECUTED 111e04: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { 111e06: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111e09: 85 c0 test %eax,%eax <== NOT EXECUTED 111e0b: 74 37 je 111e44 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; 111e0d: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 111e10: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED the_port->external_base = external_start; 111e13: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 111e16: 89 43 14 mov %eax,0x14(%ebx) <== NOT EXECUTED the_port->length = length - 1; 111e19: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 111e1c: 48 dec %eax <== NOT EXECUTED 111e1d: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED 111e20: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 111e23: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 111e26: a1 5c 6b 13 00 mov 0x136b5c,%eax <== NOT EXECUTED 111e2b: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 111e2e: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Dual_ported_memory_Information, &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; 111e31: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 111e34: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 111e36: e8 49 56 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 111e3b: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 111e3d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 111e40: 5b pop %ebx <== NOT EXECUTED 111e41: 5e pop %esi <== NOT EXECUTED 111e42: c9 leave <== NOT EXECUTED 111e43: c3 ret <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { _Thread_Enable_dispatch(); 111e44: e8 3b 56 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 111e49: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 111e4e: eb 86 jmp 111dd6 <== NOT EXECUTED 00111e50 : */ rtems_status_code rtems_port_delete( Objects_Id id ) { 111e50: 55 push %ebp <== NOT EXECUTED 111e51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111e53: 53 push %ebx <== NOT EXECUTED 111e54: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add 111e57: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 111e5a: 50 push %eax <== NOT EXECUTED 111e5b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111e5e: 68 40 6b 13 00 push $0x136b40 <== NOT EXECUTED 111e63: e8 d8 4d 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED 111e68: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111e6a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111e6d: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 111e70: 85 c9 test %ecx,%ecx <== NOT EXECUTED 111e72: 75 2c jne 111ea0 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Dual_ported_memory_Information, &the_port->Object ); 111e74: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111e77: 50 push %eax <== NOT EXECUTED 111e78: 68 40 6b 13 00 push $0x136b40 <== NOT EXECUTED 111e7d: e8 0a 49 00 00 call 11678c <_Objects_Close> <== NOT EXECUTED * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ 111e82: 58 pop %eax <== NOT EXECUTED 111e83: 5a pop %edx <== NOT EXECUTED 111e84: 53 push %ebx <== NOT EXECUTED 111e85: 68 40 6b 13 00 push $0x136b40 <== NOT EXECUTED 111e8a: e8 3d 4c 00 00 call 116acc <_Objects_Free> <== NOT EXECUTED _Dual_ported_memory_Free( the_port ); _Thread_Enable_dispatch(); 111e8f: e8 f0 55 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 111e94: 31 c0 xor %eax,%eax <== NOT EXECUTED 111e96: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111e99: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111e9c: c9 leave <== NOT EXECUTED 111e9d: c3 ret <== NOT EXECUTED 111e9e: 66 90 xchg %ax,%ax <== NOT EXECUTED { register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111ea0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111ea5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111ea8: c9 leave <== NOT EXECUTED 111ea9: c3 ret <== NOT EXECUTED 00111eac : rtems_status_code rtems_port_external_to_internal( Objects_Id id, void *external, void **internal ) { 111eac: 55 push %ebp <== NOT EXECUTED 111ead: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111eaf: 53 push %ebx <== NOT EXECUTED 111eb0: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 111eb3: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !internal ) 111eb6: 85 db test %ebx,%ebx <== NOT EXECUTED 111eb8: 74 4e je 111f08 <== NOT EXECUTED * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add 111eba: 51 push %ecx <== NOT EXECUTED 111ebb: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 111ebe: 50 push %eax <== NOT EXECUTED 111ebf: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111ec2: 68 40 6b 13 00 push $0x136b40 <== NOT EXECUTED 111ec7: e8 74 4d 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111ecc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111ecf: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 111ed2: 85 d2 test %edx,%edx <== NOT EXECUTED 111ed4: 75 1e jne 111ef4 <== NOT EXECUTED * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 111ed6: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 111ed9: 2b 50 14 sub 0x14(%eax),%edx <== NOT EXECUTED case OBJECTS_LOCAL: ending = _Addresses_Subtract( external, the_port->external_base ); if ( ending > the_port->length ) 111edc: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED 111edf: 73 1f jae 111f00 <== NOT EXECUTED *internal = external; 111ee1: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 111ee4: 89 03 mov %eax,(%ebx) <== NOT EXECUTED else *internal = _Addresses_Add_offset( the_port->internal_base, ending ); _Thread_Enable_dispatch(); 111ee6: e8 99 55 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 111eeb: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111eed: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111ef0: c9 leave <== NOT EXECUTED 111ef1: c3 ret <== NOT EXECUTED 111ef2: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !internal ) return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111ef4: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111ef9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111efc: c9 leave <== NOT EXECUTED 111efd: c3 ret <== NOT EXECUTED 111efe: 66 90 xchg %ax,%ax <== NOT EXECUTED case OBJECTS_LOCAL: ending = _Addresses_Subtract( external, the_port->external_base ); if ( ending > the_port->length ) *internal = external; else *internal = _Addresses_Add_offset( the_port->internal_base, 111f00: 03 50 10 add 0x10(%eax),%edx <== NOT EXECUTED 111f03: 89 13 mov %edx,(%ebx) <== NOT EXECUTED 111f05: eb df jmp 111ee6 <== NOT EXECUTED 111f07: 90 nop <== NOT EXECUTED { register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !internal ) 111f08: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111f0d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111f10: c9 leave <== NOT EXECUTED 111f11: c3 ret <== NOT EXECUTED 00111f14 : rtems_status_code rtems_port_ident( rtems_name name, Objects_Id *id ) { 111f14: 55 push %ebp <== NOT EXECUTED 111f15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111f17: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 111f1a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111f1d: 6a 00 push $0x0 <== NOT EXECUTED 111f1f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111f22: 68 40 6b 13 00 push $0x136b40 <== NOT EXECUTED 111f27: e8 6c 4e 00 00 call 116d98 <_Objects_Name_to_id_u32> <== NOT EXECUTED 111f2c: 8b 04 85 74 b7 12 00 mov 0x12b774(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_ALL_NODES, id ); return _Status_Object_name_errors_to_status[ status ]; } 111f33: c9 leave <== NOT EXECUTED 111f34: c3 ret <== NOT EXECUTED 00111f38 : rtems_status_code rtems_port_internal_to_external( Objects_Id id, void *internal, void **external ) { 111f38: 55 push %ebp <== NOT EXECUTED 111f39: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111f3b: 53 push %ebx <== NOT EXECUTED 111f3c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 111f3f: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !external ) 111f42: 85 db test %ebx,%ebx <== NOT EXECUTED 111f44: 74 4e je 111f94 <== NOT EXECUTED * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap * @param[in] size is the size in bytes of the memory area to add 111f46: 51 push %ecx <== NOT EXECUTED 111f47: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 111f4a: 50 push %eax <== NOT EXECUTED 111f4b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 111f4e: 68 40 6b 13 00 push $0x136b40 <== NOT EXECUTED 111f53: e8 e8 4c 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111f58: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111f5b: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 111f5e: 85 d2 test %edx,%edx <== NOT EXECUTED 111f60: 75 1e jne 111f80 <== NOT EXECUTED * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ 111f62: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 111f65: 2b 50 10 sub 0x10(%eax),%edx <== NOT EXECUTED case OBJECTS_LOCAL: ending = _Addresses_Subtract( internal, the_port->internal_base ); if ( ending > the_port->length ) 111f68: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED 111f6b: 73 1f jae 111f8c <== NOT EXECUTED *external = internal; 111f6d: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 111f70: 89 03 mov %eax,(%ebx) <== NOT EXECUTED else *external = _Addresses_Add_offset( the_port->external_base, ending ); _Thread_Enable_dispatch(); 111f72: e8 0d 55 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 111f77: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111f79: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111f7c: c9 leave <== NOT EXECUTED 111f7d: c3 ret <== NOT EXECUTED 111f7e: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !external ) return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111f80: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111f85: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111f88: c9 leave <== NOT EXECUTED 111f89: c3 ret <== NOT EXECUTED 111f8a: 66 90 xchg %ax,%ax <== NOT EXECUTED case OBJECTS_LOCAL: ending = _Addresses_Subtract( internal, the_port->internal_base ); if ( ending > the_port->length ) *external = internal; else *external = _Addresses_Add_offset( the_port->external_base, 111f8c: 03 50 14 add 0x14(%eax),%edx <== NOT EXECUTED 111f8f: 89 13 mov %edx,(%ebx) <== NOT EXECUTED 111f91: eb df jmp 111f72 <== NOT EXECUTED 111f93: 90 nop <== NOT EXECUTED { register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !external ) 111f94: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111f99: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111f9c: c9 leave <== NOT EXECUTED 111f9d: c3 ret <== NOT EXECUTED 00112a0c : */ rtems_status_code rtems_rate_monotonic_cancel( Objects_Id id ) { 112a0c: 55 push %ebp <== NOT EXECUTED 112a0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112a0f: 53 push %ebx <== NOT EXECUTED 112a10: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 112a13: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112a16: 50 push %eax <== NOT EXECUTED 112a17: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112a1a: 68 c0 6b 13 00 push $0x136bc0 <== NOT EXECUTED 112a1f: e8 1c 42 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED 112a24: 89 c3 mov %eax,%ebx <== NOT EXECUTED Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 112a26: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112a29: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 112a2c: 85 c0 test %eax,%eax <== NOT EXECUTED 112a2e: 74 0c je 112a3c <== NOT EXECUTED 112a30: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112a35: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112a38: c9 leave <== NOT EXECUTED 112a39: c3 ret <== NOT EXECUTED 112a3a: 66 90 xchg %ax,%ax <== NOT EXECUTED the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 112a3c: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 112a3f: 3b 05 3c 6e 13 00 cmp 0x136e3c,%eax <== NOT EXECUTED 112a45: 74 11 je 112a58 <== NOT EXECUTED _Thread_Enable_dispatch(); 112a47: e8 38 4a 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 112a4c: b8 17 00 00 00 mov $0x17,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112a51: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112a54: c9 leave <== NOT EXECUTED 112a55: c3 ret <== NOT EXECUTED 112a56: 66 90 xchg %ax,%ax <== NOT EXECUTED case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } (void) _Watchdog_Remove( &the_period->Timer ); 112a58: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 112a5b: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 112a5e: 50 push %eax <== NOT EXECUTED 112a5f: e8 18 5e 00 00 call 11887c <_Watchdog_Remove> <== NOT EXECUTED the_period->state = RATE_MONOTONIC_INACTIVE; 112a64: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 112a6b: e8 14 4a 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 112a70: 31 c0 xor %eax,%eax <== NOT EXECUTED 112a72: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112a75: eb be jmp 112a35 <== NOT EXECUTED 0010af98 : rtems_status_code rtems_rate_monotonic_create( rtems_name name, Objects_Id *id ) { 10af98: 55 push %ebp <== NOT EXECUTED 10af99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10af9b: 57 push %edi <== NOT EXECUTED 10af9c: 56 push %esi <== NOT EXECUTED 10af9d: 53 push %ebx <== NOT EXECUTED 10af9e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10afa1: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 10afa4: 85 f6 test %esi,%esi <== NOT EXECUTED 10afa6: 0f 84 a8 00 00 00 je 10b054 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 10afac: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10afaf: 85 c0 test %eax,%eax <== NOT EXECUTED 10afb1: 0f 84 c1 00 00 00 je 10b078 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10afb7: a1 58 3f 12 00 mov 0x123f58,%eax <== NOT EXECUTED 10afbc: 40 inc %eax <== NOT EXECUTED 10afbd: a3 58 3f 12 00 mov %eax,0x123f58 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10afc2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10afc5: 68 60 3e 12 00 push $0x123e60 <== NOT EXECUTED 10afca: e8 7d 1e 00 00 call 10ce4c <_Objects_Allocate> <== NOT EXECUTED 10afcf: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { 10afd1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10afd4: 85 c0 test %eax,%eax <== NOT EXECUTED 10afd6: 0f 84 88 00 00 00 je 10b064 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 10afdc: a1 1c 40 12 00 mov 0x12401c,%eax <== NOT EXECUTED 10afe1: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED the_period->state = RATE_MONOTONIC_INACTIVE; 10afe4: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10afeb: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10aff2: c7 43 2c 00 00 00 00 movl $0x0,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10aff9: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx) <== NOT EXECUTED * the heap 10b000: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 10b007: 8d 7b 54 lea 0x54(%ebx),%edi <== NOT EXECUTED 10b00a: b9 38 00 00 00 mov $0x38,%ecx <== NOT EXECUTED 10b00f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b011: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 10b013: c7 43 5c ff ff ff 7f movl $0x7fffffff,0x5c(%ebx) <== NOT EXECUTED 10b01a: c7 43 60 ff ff ff 7f movl $0x7fffffff,0x60(%ebx) <== NOT EXECUTED 10b021: c7 43 74 ff ff ff 7f movl $0x7fffffff,0x74(%ebx) <== NOT EXECUTED 10b028: c7 43 78 ff ff ff 7f movl $0x7fffffff,0x78(%ebx) <== NOT EXECUTED 10b02f: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10b032: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10b035: a1 7c 3e 12 00 mov 0x123e7c,%eax <== NOT EXECUTED 10b03a: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10b03d: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Rate_monotonic_Information, &the_period->Object, (Objects_Name) name ); *id = the_period->Object.id; 10b040: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b043: 89 08 mov %ecx,(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10b045: e8 3a 2c 00 00 call 10dc84 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b04a: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10b04c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b04f: 5b pop %ebx <== NOT EXECUTED 10b050: 5e pop %esi <== NOT EXECUTED 10b051: 5f pop %edi <== NOT EXECUTED 10b052: c9 leave <== NOT EXECUTED 10b053: c3 ret <== NOT EXECUTED Objects_Id *id ) { Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 10b054: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b059: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b05c: 5b pop %ebx <== NOT EXECUTED 10b05d: 5e pop %esi <== NOT EXECUTED 10b05e: 5f pop %edi <== NOT EXECUTED 10b05f: c9 leave <== NOT EXECUTED 10b060: c3 ret <== NOT EXECUTED 10b061: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { _Thread_Enable_dispatch(); 10b064: e8 1b 2c 00 00 call 10dc84 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b069: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b06e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b071: 5b pop %ebx <== NOT EXECUTED 10b072: 5e pop %esi <== NOT EXECUTED 10b073: 5f pop %edi <== NOT EXECUTED 10b074: c9 leave <== NOT EXECUTED 10b075: c3 ret <== NOT EXECUTED 10b076: 66 90 xchg %ax,%ax <== NOT EXECUTED Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 10b078: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b07d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b080: 5b pop %ebx <== NOT EXECUTED 10b081: 5e pop %esi <== NOT EXECUTED 10b082: 5f pop %edi <== NOT EXECUTED 10b083: c9 leave <== NOT EXECUTED 10b084: c3 ret <== NOT EXECUTED 00112b68 : */ rtems_status_code rtems_rate_monotonic_delete( Objects_Id id ) { 112b68: 55 push %ebp <== NOT EXECUTED 112b69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 112b6b: 53 push %ebx <== NOT EXECUTED 112b6c: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 112b6f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 112b72: 50 push %eax <== NOT EXECUTED 112b73: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 112b76: 68 c0 6b 13 00 push $0x136bc0 <== NOT EXECUTED 112b7b: e8 c0 40 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED 112b80: 89 c3 mov %eax,%ebx <== NOT EXECUTED Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 112b82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 112b85: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 112b88: 85 c9 test %ecx,%ecx <== NOT EXECUTED 112b8a: 75 3c jne 112bc8 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Rate_monotonic_Information, &the_period->Object ); 112b8c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 112b8f: 50 push %eax <== NOT EXECUTED 112b90: 68 c0 6b 13 00 push $0x136bc0 <== NOT EXECUTED 112b95: e8 f2 3b 00 00 call 11678c <_Objects_Close> <== NOT EXECUTED (void) _Watchdog_Remove( &the_period->Timer ); 112b9a: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 112b9d: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 112ba0: e8 d7 5c 00 00 call 11887c <_Watchdog_Remove> <== NOT EXECUTED the_period->state = RATE_MONOTONIC_INACTIVE; 112ba5: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) <== NOT EXECUTED * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. 112bac: 58 pop %eax <== NOT EXECUTED 112bad: 5a pop %edx <== NOT EXECUTED 112bae: 53 push %ebx <== NOT EXECUTED 112baf: 68 c0 6b 13 00 push $0x136bc0 <== NOT EXECUTED 112bb4: e8 13 3f 00 00 call 116acc <_Objects_Free> <== NOT EXECUTED _Rate_monotonic_Free( the_period ); _Thread_Enable_dispatch(); 112bb9: e8 c6 48 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 112bbe: 31 c0 xor %eax,%eax <== NOT EXECUTED 112bc0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112bc3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112bc6: c9 leave <== NOT EXECUTED 112bc7: c3 ret <== NOT EXECUTED { Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 112bc8: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112bcd: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 112bd0: c9 leave <== NOT EXECUTED 112bd1: c3 ret <== NOT EXECUTED 0012ff24 : rtems_status_code rtems_rate_monotonic_get_statistics( Objects_Id id, rtems_rate_monotonic_period_statistics *statistics ) { 12ff24: 55 push %ebp <== NOT EXECUTED 12ff25: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12ff27: 57 push %edi <== NOT EXECUTED 12ff28: 56 push %esi <== NOT EXECUTED 12ff29: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 12ff2c: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 12ff2f: 85 ff test %edi,%edi <== NOT EXECUTED 12ff31: 74 41 je 12ff74 <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 12ff33: 51 push %ecx <== NOT EXECUTED 12ff34: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 12ff37: 50 push %eax <== NOT EXECUTED 12ff38: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12ff3b: 68 e0 2b 16 00 push $0x162be0 <== NOT EXECUTED 12ff40: e8 3f 0f fe ff call 110e84 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 12ff45: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12ff48: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 12ff4b: 85 d2 test %edx,%edx <== NOT EXECUTED 12ff4d: 74 0d je 12ff5c <== NOT EXECUTED 12ff4f: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12ff54: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12ff57: 5e pop %esi <== NOT EXECUTED 12ff58: 5f pop %edi <== NOT EXECUTED 12ff59: c9 leave <== NOT EXECUTED 12ff5a: c3 ret <== NOT EXECUTED 12ff5b: 90 nop <== NOT EXECUTED the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *statistics = the_period->Statistics; 12ff5c: 8d 70 54 lea 0x54(%eax),%esi <== NOT EXECUTED 12ff5f: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 12ff64: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 12ff66: e8 0d 18 fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 12ff6b: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12ff6d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12ff70: 5e pop %esi <== NOT EXECUTED 12ff71: 5f pop %edi <== NOT EXECUTED 12ff72: c9 leave <== NOT EXECUTED 12ff73: c3 ret <== NOT EXECUTED ) { Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 12ff74: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12ff79: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12ff7c: 5e pop %esi <== NOT EXECUTED 12ff7d: 5f pop %edi <== NOT EXECUTED 12ff7e: c9 leave <== NOT EXECUTED 12ff7f: c3 ret <== NOT EXECUTED 0012ff80 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 12ff80: 55 push %ebp <== NOT EXECUTED 12ff81: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12ff83: 57 push %edi <== NOT EXECUTED 12ff84: 56 push %esi <== NOT EXECUTED 12ff85: 53 push %ebx <== NOT EXECUTED 12ff86: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 12ff89: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 12ff8c: 85 f6 test %esi,%esi <== NOT EXECUTED 12ff8e: 74 70 je 130000 <== NOT EXECUTED 12ff90: 52 push %edx <== NOT EXECUTED 12ff91: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 12ff94: 50 push %eax <== NOT EXECUTED 12ff95: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12ff98: 68 e0 2b 16 00 push $0x162be0 <== NOT EXECUTED 12ff9d: e8 e2 0e fe ff call 110e84 <_Objects_Get> <== NOT EXECUTED 12ffa2: 89 c7 mov %eax,%edi <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 12ffa4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12ffa7: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 12ffaa: 85 c0 test %eax,%eax <== NOT EXECUTED 12ffac: 75 42 jne 12fff0 <== NOT EXECUTED case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 12ffae: 8b 47 50 mov 0x50(%edi),%eax <== NOT EXECUTED 12ffb1: 85 c0 test %eax,%eax <== NOT EXECUTED 12ffb3: 74 03 je 12ffb8 <== NOT EXECUTED 12ffb5: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 12ffb8: 89 06 mov %eax,(%esi) <== NOT EXECUTED status->state = the_period->state; 12ffba: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 12ffbd: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED if ( status->state == RATE_MONOTONIC_INACTIVE ) { 12ffc0: 85 c0 test %eax,%eax <== NOT EXECUTED 12ffc2: 75 4c jne 130010 <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS status->since_last_period.tv_sec = 0; 12ffc4: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) <== NOT EXECUTED status->since_last_period.tv_nsec = 0; 12ffcb: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) <== NOT EXECUTED #else status->since_last_period = 0; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS status->executed_since_last_period.tv_sec = 0; 12ffd2: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi) <== NOT EXECUTED status->executed_since_last_period.tv_nsec = 0; 12ffd9: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED the_period->owner->cpu_time_used - the_period->owner_executed_at_period; #endif } _Thread_Enable_dispatch(); 12ffe0: e8 93 17 fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 12ffe5: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12ffe7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12ffea: 5b pop %ebx <== NOT EXECUTED 12ffeb: 5e pop %esi <== NOT EXECUTED 12ffec: 5f pop %edi <== NOT EXECUTED 12ffed: c9 leave <== NOT EXECUTED 12ffee: c3 ret <== NOT EXECUTED 12ffef: 90 nop <== NOT EXECUTED if ( !status ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 12fff0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12fff5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12fff8: 5b pop %ebx <== NOT EXECUTED 12fff9: 5e pop %esi <== NOT EXECUTED 12fffa: 5f pop %edi <== NOT EXECUTED 12fffb: c9 leave <== NOT EXECUTED 12fffc: c3 ret <== NOT EXECUTED 12fffd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 130000: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 130005: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 130008: 5b pop %ebx <== NOT EXECUTED 130009: 5e pop %esi <== NOT EXECUTED 13000a: 5f pop %edi <== NOT EXECUTED 13000b: c9 leave <== NOT EXECUTED 13000c: c3 ret <== NOT EXECUTED 13000d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * This lets them share one single invocation of _TOD_Get_uptime(). */ #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) struct timespec uptime; _TOD_Get_uptime( &uptime ); 130010: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 130013: 8d 5d e8 lea -0x18(%ebp),%ebx <== NOT EXECUTED 130016: 53 push %ebx <== NOT EXECUTED 130017: e8 64 6d ff ff call 126d80 <_TOD_Get_uptime> <== NOT EXECUTED #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 13001c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 13001f: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED 130022: 50 push %eax <== NOT EXECUTED 130023: 53 push %ebx <== NOT EXECUTED 130024: 8d 47 44 lea 0x44(%edi),%eax <== NOT EXECUTED 130027: 50 push %eax <== NOT EXECUTED 130028: e8 b3 23 fe ff call 1123e0 <_Timespec_Subtract> <== NOT EXECUTED status->since_last_period = _Watchdog_Ticks_since_boot - the_period->time_at_period; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _Timespec_Subtract( 13002d: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 130030: 8d 46 10 lea 0x10(%esi),%eax <== NOT EXECUTED 130033: 50 push %eax <== NOT EXECUTED 130034: 53 push %ebx <== NOT EXECUTED 130035: 68 c4 1f 16 00 push $0x161fc4 <== NOT EXECUTED 13003a: e8 a1 23 fe ff call 1123e0 <_Timespec_Subtract> <== NOT EXECUTED 13003f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 130042: eb 9c jmp 12ffe0 <== NOT EXECUTED 0010b088 : rtems_status_code rtems_rate_monotonic_ident( rtems_name name, Objects_Id *id ) { 10b088: 55 push %ebp <== NOT EXECUTED 10b089: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b08b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 10b08e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b091: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 10b096: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b099: 68 60 3e 12 00 push $0x123e60 <== NOT EXECUTED 10b09e: e8 f5 24 00 00 call 10d598 <_Objects_Name_to_id_u32> <== NOT EXECUTED 10b0a3: 8b 04 85 74 cc 11 00 mov 0x11cc74(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 10b0aa: c9 leave <== NOT EXECUTED 10b0ab: c3 ret <== NOT EXECUTED 0010b270 : rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) { 10b270: 55 push %ebp <== NOT EXECUTED 10b271: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b273: 57 push %edi <== NOT EXECUTED 10b274: 56 push %esi <== NOT EXECUTED 10b275: 53 push %ebx <== NOT EXECUTED 10b276: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 10b279: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 10b27c: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b27f: 50 push %eax <== NOT EXECUTED 10b280: 56 push %esi <== NOT EXECUTED 10b281: 68 60 3e 12 00 push $0x123e60 <== NOT EXECUTED 10b286: e8 b5 21 00 00 call 10d440 <_Objects_Get> <== NOT EXECUTED 10b28b: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 10b28d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b290: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10b293: 85 c0 test %eax,%eax <== NOT EXECUTED 10b295: 74 11 je 10b2a8 <== NOT EXECUTED the_period->state = RATE_MONOTONIC_ACTIVE; the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); return RTEMS_TIMEOUT; 10b297: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b29c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b29e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b2a1: 5b pop %ebx <== NOT EXECUTED 10b2a2: 5e pop %esi <== NOT EXECUTED 10b2a3: 5f pop %edi <== NOT EXECUTED 10b2a4: c9 leave <== NOT EXECUTED 10b2a5: c3 ret <== NOT EXECUTED 10b2a6: 66 90 xchg %ax,%ax <== NOT EXECUTED the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 10b2a8: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10b2ab: 3b 05 1c 40 12 00 cmp 0x12401c,%eax <== NOT EXECUTED 10b2b1: 74 15 je 10b2c8 <== NOT EXECUTED _Thread_Enable_dispatch(); 10b2b3: e8 cc 29 00 00 call 10dc84 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b2b8: bb 17 00 00 00 mov $0x17,%ebx <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b2bd: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b2bf: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b2c2: 5b pop %ebx <== NOT EXECUTED 10b2c3: 5e pop %esi <== NOT EXECUTED 10b2c4: 5f pop %edi <== NOT EXECUTED 10b2c5: c9 leave <== NOT EXECUTED 10b2c6: c3 ret <== NOT EXECUTED 10b2c7: 90 nop <== NOT EXECUTED if ( !_Thread_Is_executing( the_period->owner ) ) { _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 10b2c8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b2cb: 85 c0 test %eax,%eax <== NOT EXECUTED 10b2cd: 0f 84 c1 00 00 00 je 10b394 <== NOT EXECUTED } _Thread_Enable_dispatch(); return( return_value ); } _ISR_Disable( level ); 10b2d3: 9c pushf <== NOT EXECUTED 10b2d4: fa cli <== NOT EXECUTED 10b2d5: 5f pop %edi <== NOT EXECUTED switch ( the_period->state ) { 10b2d6: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10b2d9: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b2dc: 74 62 je 10b340 <== NOT EXECUTED 10b2de: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10b2e1: 0f 84 c5 00 00 00 je 10b3ac <== NOT EXECUTED 10b2e7: 85 c0 test %eax,%eax <== NOT EXECUTED 10b2e9: 75 ac jne 10b297 <== NOT EXECUTED case RATE_MONOTONIC_INACTIVE: { _ISR_Enable( level ); 10b2eb: 57 push %edi <== NOT EXECUTED 10b2ec: 9d popf <== NOT EXECUTED /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 10b2ed: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b2f0: 53 push %ebx <== NOT EXECUTED 10b2f1: e8 b6 fd ff ff call 10b0ac <_Rate_monotonic_Initiate_statistics> <== NOT EXECUTED the_period->state = RATE_MONOTONIC_ACTIVE; 10b2f6: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10b2fd: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10b304: c7 43 2c e0 b6 10 00 movl $0x10b6e0,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10b30b: 89 73 30 mov %esi,0x30(%ebx) <== NOT EXECUTED * the heap 10b30e: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 10b315: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b318: 89 43 4c mov %eax,0x4c(%ebx) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10b31b: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10b31e: 5f pop %edi <== NOT EXECUTED 10b31f: 58 pop %eax <== NOT EXECUTED 10b320: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10b323: 50 push %eax <== NOT EXECUTED 10b324: 68 3c 40 12 00 push $0x12403c <== NOT EXECUTED 10b329: e8 2a 3a 00 00 call 10ed58 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10b32e: e8 51 29 00 00 call 10dc84 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b333: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b335: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b338: e9 5f ff ff ff jmp 10b29c <== NOT EXECUTED 10b33d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED case RATE_MONOTONIC_ACTIVE: /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 10b340: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b343: 53 push %ebx <== NOT EXECUTED 10b344: e8 d3 fd ff ff call 10b11c <_Rate_monotonic_Update_statistics> <== NOT EXECUTED /* * 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; 10b349: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) <== NOT EXECUTED the_period->next_length = length; 10b350: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b353: 89 43 4c mov %eax,0x4c(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10b356: 57 push %edi <== NOT EXECUTED 10b357: 9d popf <== NOT EXECUTED _Thread_Executing->Wait.id = the_period->Object.id; 10b358: 8b 15 1c 40 12 00 mov 0x12401c,%edx <== NOT EXECUTED 10b35e: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10b361: 89 42 20 mov %eax,0x20(%edx) <== NOT EXECUTED _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b364: 59 pop %ecx <== NOT EXECUTED 10b365: 5e pop %esi <== NOT EXECUTED 10b366: 68 00 40 00 00 push $0x4000 <== NOT EXECUTED 10b36b: 52 push %edx <== NOT EXECUTED 10b36c: e8 f3 31 00 00 call 10e564 <_Thread_Set_state> <== NOT EXECUTED /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 10b371: 9c pushf <== NOT EXECUTED 10b372: fa cli <== NOT EXECUTED 10b373: 58 pop %eax <== NOT EXECUTED local_state = the_period->state; 10b374: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED the_period->state = RATE_MONOTONIC_ACTIVE; 10b377: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10b37e: 50 push %eax <== NOT EXECUTED 10b37f: 9d popf <== NOT EXECUTED /* * If it did, then we want to unblock ourself and continue as * if nothing happen. The period was reset in the timeout routine. */ if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) 10b380: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b383: 83 fa 03 cmp $0x3,%edx <== NOT EXECUTED 10b386: 74 71 je 10b3f9 <== NOT EXECUTED _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); _Thread_Enable_dispatch(); 10b388: e8 f7 28 00 00 call 10dc84 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b38d: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b38f: e9 08 ff ff ff jmp 10b29c <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { switch ( the_period->state ) { 10b394: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10b397: 85 c0 test %eax,%eax <== NOT EXECUTED 10b399: 75 51 jne 10b3ec <== NOT EXECUTED 10b39b: bb 0b 00 00 00 mov $0xb,%ebx <== NOT EXECUTED case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 10b3a0: e8 df 28 00 00 call 10dc84 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b3a5: e9 f2 fe ff ff jmp 10b29c <== NOT EXECUTED 10b3aa: 66 90 xchg %ax,%ax <== NOT EXECUTED case RATE_MONOTONIC_EXPIRED: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 10b3ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b3af: 53 push %ebx <== NOT EXECUTED 10b3b0: e8 67 fd ff ff call 10b11c <_Rate_monotonic_Update_statistics> <== NOT EXECUTED _ISR_Enable( level ); 10b3b5: 57 push %edi <== NOT EXECUTED 10b3b6: 9d popf <== NOT EXECUTED the_period->state = RATE_MONOTONIC_ACTIVE; 10b3b7: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) <== NOT EXECUTED the_period->next_length = length; 10b3be: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b3c1: 89 43 4c mov %eax,0x4c(%ebx) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10b3c4: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10b3c7: 58 pop %eax <== NOT EXECUTED 10b3c8: 5a pop %edx <== NOT EXECUTED 10b3c9: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10b3cc: 50 push %eax <== NOT EXECUTED 10b3cd: 68 3c 40 12 00 push $0x12403c <== NOT EXECUTED 10b3d2: e8 81 39 00 00 call 10ed58 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10b3d7: e8 a8 28 00 00 call 10dc84 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b3dc: bb 06 00 00 00 mov $0x6,%ebx <== NOT EXECUTED 10b3e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b3e4: e9 b3 fe ff ff jmp 10b29c <== NOT EXECUTED 10b3e9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { switch ( the_period->state ) { 10b3ec: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED 10b3ef: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b3f2: 19 db sbb %ebx,%ebx <== NOT EXECUTED 10b3f4: 83 e3 06 and $0x6,%ebx <== NOT EXECUTED 10b3f7: eb a7 jmp 10b3a0 <== NOT EXECUTED /* * If it did, then we want to unblock ourself and continue as * if nothing happen. The period was reset in the timeout routine. */ if ( local_state == RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING ) _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b3f9: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b3fc: 68 00 40 00 00 push $0x4000 <== NOT EXECUTED 10b401: ff 35 1c 40 12 00 pushl 0x12401c <== NOT EXECUTED 10b407: e8 d0 24 00 00 call 10d8dc <_Thread_Clear_state> <== NOT EXECUTED 10b40c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b40f: e9 74 ff ff ff jmp 10b388 <== NOT EXECUTED 00126320 : } } } void rtems_rate_monotonic_report_statistics( void ) { 126320: 55 push %ebp <== NOT EXECUTED 126321: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126323: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin ); 126326: 68 8c c7 10 00 push $0x10c78c <== NOT EXECUTED 12632b: 6a 00 push $0x0 <== NOT EXECUTED 12632d: e8 de fd ff ff call 126110 <== NOT EXECUTED 126332: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 126335: c9 leave <== NOT EXECUTED 126336: c3 ret <== NOT EXECUTED 00126110 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 126110: 55 push %ebp <== NOT EXECUTED 126111: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126113: 57 push %edi <== NOT EXECUTED 126114: 56 push %esi <== NOT EXECUTED 126115: 53 push %ebx <== NOT EXECUTED 126116: 81 ec 9c 00 00 00 sub $0x9c,%esp <== NOT EXECUTED 12611c: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 12611f: 85 ff test %edi,%edi <== NOT EXECUTED 126121: 0f 84 c9 00 00 00 je 1261f0 <== NOT EXECUTED return; (*print)( context, "Period information by period\n" ); 126127: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12612a: 68 78 53 14 00 push $0x145378 <== NOT EXECUTED 12612f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126132: ff d7 call *%edi <== NOT EXECUTED #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 126134: 5e pop %esi <== NOT EXECUTED 126135: 58 pop %eax <== NOT EXECUTED 126136: 68 b0 53 14 00 push $0x1453b0 <== NOT EXECUTED 12613b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12613e: ff d7 call *%edi <== NOT EXECUTED #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 126140: 59 pop %ecx <== NOT EXECUTED 126141: 5b pop %ebx <== NOT EXECUTED 126142: 68 d4 53 14 00 push $0x1453d4 <== NOT EXECUTED 126147: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12614a: ff d7 call *%edi <== NOT EXECUTED Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 12614c: 58 pop %eax <== NOT EXECUTED 12614d: 5a pop %edx <== NOT EXECUTED 12614e: 68 f8 53 14 00 push $0x1453f8 <== NOT EXECUTED 126153: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126156: ff d7 call *%edi <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 126158: 5b pop %ebx <== NOT EXECUTED 126159: 5e pop %esi <== NOT EXECUTED 12615a: 68 44 54 14 00 push $0x145444 <== NOT EXECUTED 12615f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126162: ff d7 call *%edi <== NOT EXECUTED /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 126164: 8b 35 e8 2b 16 00 mov 0x162be8,%esi <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; 12616a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12616d: 3b 35 ec 2b 16 00 cmp 0x162bec,%esi <== NOT EXECUTED 126173: 76 0c jbe 126181 <== NOT EXECUTED 126175: eb 79 jmp 1261f0 <== NOT EXECUTED 126177: 90 nop <== NOT EXECUTED id++ ) { 126178: 46 inc %esi <== NOT EXECUTED /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; 126179: 39 35 ec 2b 16 00 cmp %esi,0x162bec <== NOT EXECUTED 12617f: 72 6f jb 1261f0 <== NOT EXECUTED id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 126181: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 126184: 8d 45 90 lea -0x70(%ebp),%eax <== NOT EXECUTED 126187: 50 push %eax <== NOT EXECUTED 126188: 56 push %esi <== NOT EXECUTED 126189: e8 96 9d 00 00 call 12ff24 <== NOT EXECUTED if ( status != RTEMS_SUCCESSFUL ) 12618e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126191: 85 c0 test %eax,%eax <== NOT EXECUTED 126193: 75 e3 jne 126178 <== NOT EXECUTED continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 126195: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 126198: 8d 55 c8 lea -0x38(%ebp),%edx <== NOT EXECUTED 12619b: 52 push %edx <== NOT EXECUTED 12619c: 56 push %esi <== NOT EXECUTED 12619d: e8 de 9d 00 00 call 12ff80 <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( status != RTEMS_SUCCESSFUL ) continue; #endif name[ 0 ] = '\0'; 1261a2: c6 45 eb 00 movb $0x0,-0x15(%ebp) <== NOT EXECUTED if ( the_status.owner ) { 1261a6: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 1261a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1261ac: 85 c0 test %eax,%eax <== NOT EXECUTED 1261ae: 0f 85 54 01 00 00 jne 126308 <== NOT EXECUTED 1261b4: 8d 5d eb lea -0x15(%ebp),%ebx <== NOT EXECUTED /* * Print part of report line that is not dependent on granularity */ (*print)( context, 1261b7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1261ba: ff 75 94 pushl -0x6c(%ebp) <== NOT EXECUTED 1261bd: ff 75 90 pushl -0x70(%ebp) <== NOT EXECUTED 1261c0: 53 push %ebx <== NOT EXECUTED 1261c1: 56 push %esi <== NOT EXECUTED 1261c2: 68 96 53 14 00 push $0x145396 <== NOT EXECUTED 1261c7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1261ca: ff d7 call *%edi <== NOT EXECUTED /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 1261cc: 8b 45 90 mov -0x70(%ebp),%eax <== NOT EXECUTED 1261cf: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1261d2: 85 c0 test %eax,%eax <== NOT EXECUTED 1261d4: 75 22 jne 1261f8 <== NOT EXECUTED (*print)( context, "\n" ); 1261d6: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1261d9: 68 68 57 14 00 push $0x145768 <== NOT EXECUTED 1261de: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1261e1: ff d7 call *%edi <== NOT EXECUTED 1261e3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 1261e6: 46 inc %esi <== NOT EXECUTED /* * Cycle through all possible ids and try to report on each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; 1261e7: 39 35 ec 2b 16 00 cmp %esi,0x162bec <== NOT EXECUTED 1261ed: 73 92 jae 126181 <== NOT EXECUTED 1261ef: 90 nop <== NOT EXECUTED the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 1261f0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1261f3: 5b pop %ebx <== NOT EXECUTED 1261f4: 5e pop %esi <== NOT EXECUTED 1261f5: 5f pop %edi <== NOT EXECUTED 1261f6: c9 leave <== NOT EXECUTED 1261f7: c3 ret <== NOT EXECUTED */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 1261f8: 52 push %edx <== NOT EXECUTED 1261f9: 8d 55 e0 lea -0x20(%ebp),%edx <== NOT EXECUTED 1261fc: 52 push %edx <== NOT EXECUTED 1261fd: 50 push %eax <== NOT EXECUTED 1261fe: 8d 45 a8 lea -0x58(%ebp),%eax <== NOT EXECUTED 126201: 50 push %eax <== NOT EXECUTED 126202: e8 1d 15 00 00 call 127724 <_Timespec_Divide_by_integer> <== NOT EXECUTED &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 126207: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 12620a: bb d3 4d 62 10 mov $0x10624dd3,%ebx <== NOT EXECUTED 12620f: 89 c8 mov %ecx,%eax <== NOT EXECUTED 126211: f7 eb imul %ebx <== NOT EXECUTED 126213: 89 45 88 mov %eax,-0x78(%ebp) <== NOT EXECUTED 126216: 89 55 8c mov %edx,-0x74(%ebp) <== NOT EXECUTED 126219: 8b 45 8c mov -0x74(%ebp),%eax <== NOT EXECUTED 12621c: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 12621f: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 126222: 29 c8 sub %ecx,%eax <== NOT EXECUTED 126224: 50 push %eax <== NOT EXECUTED 126225: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 126228: 8b 4d a4 mov -0x5c(%ebp),%ecx <== NOT EXECUTED 12622b: 89 c8 mov %ecx,%eax <== NOT EXECUTED 12622d: f7 eb imul %ebx <== NOT EXECUTED 12622f: 89 45 80 mov %eax,-0x80(%ebp) <== NOT EXECUTED 126232: 89 55 84 mov %edx,-0x7c(%ebp) <== NOT EXECUTED 126235: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 126238: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 12623b: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 12623e: 29 c8 sub %ecx,%eax <== NOT EXECUTED 126240: 50 push %eax <== NOT EXECUTED 126241: ff 75 a0 pushl -0x60(%ebp) <== NOT EXECUTED 126244: 8b 4d 9c mov -0x64(%ebp),%ecx <== NOT EXECUTED 126247: 89 c8 mov %ecx,%eax <== NOT EXECUTED 126249: f7 eb imul %ebx <== NOT EXECUTED 12624b: 89 85 78 ff ff ff mov %eax,-0x88(%ebp) <== NOT EXECUTED 126251: 89 95 7c ff ff ff mov %edx,-0x84(%ebp) <== NOT EXECUTED 126257: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax <== NOT EXECUTED 12625d: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 126260: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 126263: 29 c8 sub %ecx,%eax <== NOT EXECUTED 126265: 50 push %eax <== NOT EXECUTED 126266: ff 75 98 pushl -0x68(%ebp) <== NOT EXECUTED 126269: 68 90 54 14 00 push $0x145490 <== NOT EXECUTED 12626e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126271: ff d7 call *%edi <== NOT EXECUTED * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 126273: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 126276: 8d 55 e0 lea -0x20(%ebp),%edx <== NOT EXECUTED 126279: 52 push %edx <== NOT EXECUTED 12627a: ff 75 90 pushl -0x70(%ebp) <== NOT EXECUTED 12627d: 8d 45 c0 lea -0x40(%ebp),%eax <== NOT EXECUTED 126280: 50 push %eax <== NOT EXECUTED 126281: e8 9e 14 00 00 call 127724 <_Timespec_Divide_by_integer> <== NOT EXECUTED &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 126286: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 126289: 89 c8 mov %ecx,%eax <== NOT EXECUTED 12628b: f7 eb imul %ebx <== NOT EXECUTED 12628d: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) <== NOT EXECUTED 126293: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) <== NOT EXECUTED 126299: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax <== NOT EXECUTED 12629f: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 1262a2: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 1262a5: 29 c8 sub %ecx,%eax <== NOT EXECUTED 1262a7: 50 push %eax <== NOT EXECUTED 1262a8: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 1262ab: 8b 4d bc mov -0x44(%ebp),%ecx <== NOT EXECUTED 1262ae: 89 c8 mov %ecx,%eax <== NOT EXECUTED 1262b0: f7 eb imul %ebx <== NOT EXECUTED 1262b2: 89 85 68 ff ff ff mov %eax,-0x98(%ebp) <== NOT EXECUTED 1262b8: 89 95 6c ff ff ff mov %edx,-0x94(%ebp) <== NOT EXECUTED 1262be: 8b 85 6c ff ff ff mov -0x94(%ebp),%eax <== NOT EXECUTED 1262c4: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 1262c7: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 1262ca: 29 c8 sub %ecx,%eax <== NOT EXECUTED 1262cc: 50 push %eax <== NOT EXECUTED 1262cd: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 1262d0: 8b 4d b4 mov -0x4c(%ebp),%ecx <== NOT EXECUTED 1262d3: 89 c8 mov %ecx,%eax <== NOT EXECUTED 1262d5: f7 eb imul %ebx <== NOT EXECUTED 1262d7: 89 85 60 ff ff ff mov %eax,-0xa0(%ebp) <== NOT EXECUTED 1262dd: 89 95 64 ff ff ff mov %edx,-0x9c(%ebp) <== NOT EXECUTED 1262e3: 8b 85 64 ff ff ff mov -0x9c(%ebp),%eax <== NOT EXECUTED 1262e9: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 1262ec: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 1262ef: 29 c8 sub %ecx,%eax <== NOT EXECUTED 1262f1: 50 push %eax <== NOT EXECUTED 1262f2: ff 75 b0 pushl -0x50(%ebp) <== NOT EXECUTED 1262f5: 68 b0 54 14 00 push $0x1454b0 <== NOT EXECUTED 1262fa: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1262fd: ff d7 call *%edi <== NOT EXECUTED 1262ff: 83 c4 30 add $0x30,%esp <== NOT EXECUTED 126302: e9 71 fe ff ff jmp 126178 <== NOT EXECUTED 126307: 90 nop <== NOT EXECUTED #endif name[ 0 ] = '\0'; if ( the_status.owner ) { rtems_object_get_name( the_status.owner, sizeof(name), name ); 126308: 51 push %ecx <== NOT EXECUTED 126309: 8d 5d eb lea -0x15(%ebp),%ebx <== NOT EXECUTED 12630c: 53 push %ebx <== NOT EXECUTED 12630d: 6a 05 push $0x5 <== NOT EXECUTED 12630f: 50 push %eax <== NOT EXECUTED 126310: e8 f3 8d fe ff call 10f108 <== NOT EXECUTED 126315: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126318: e9 9a fe ff ff jmp 1261b7 <== NOT EXECUTED 00126338 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 126338: 55 push %ebp <== NOT EXECUTED 126339: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12633b: 53 push %ebx <== NOT EXECUTED 12633c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 12633f: a1 f8 1e 16 00 mov 0x161ef8,%eax <== NOT EXECUTED 126344: 40 inc %eax <== NOT EXECUTED 126345: a3 f8 1e 16 00 mov %eax,0x161ef8 <== NOT EXECUTED /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; 12634a: 8b 1d e8 2b 16 00 mov 0x162be8,%ebx <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; 126350: 3b 1d ec 2b 16 00 cmp 0x162bec,%ebx <== NOT EXECUTED 126356: 77 15 ja 12636d <== NOT EXECUTED id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 126358: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12635b: 53 push %ebx <== NOT EXECUTED 12635c: e8 17 00 00 00 call 126378 <== NOT EXECUTED * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; id++ ) { 126361: 43 inc %ebx <== NOT EXECUTED /* * Cycle through all possible ids and try to reset each one. If it * is a period that is inactive, we just get an error back. No big deal. */ for ( id=_Rate_monotonic_Information.minimum_id ; id <= _Rate_monotonic_Information.maximum_id ; 126362: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126365: 39 1d ec 2b 16 00 cmp %ebx,0x162bec <== NOT EXECUTED 12636b: 73 eb jae 126358 <== NOT EXECUTED /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); } 12636d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 126370: c9 leave <== NOT EXECUTED } /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); 126371: e9 02 b4 fe ff jmp 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 00126378 : */ rtems_status_code rtems_rate_monotonic_reset_statistics( Objects_Id id ) { 126378: 55 push %ebp <== NOT EXECUTED 126379: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12637b: 57 push %edi <== NOT EXECUTED 12637c: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory 12637f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 126382: 50 push %eax <== NOT EXECUTED 126383: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126386: 68 e0 2b 16 00 push $0x162be0 <== NOT EXECUTED 12638b: e8 f4 aa fe ff call 110e84 <_Objects_Get> <== NOT EXECUTED 126390: 89 c2 mov %eax,%edx <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 126392: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126395: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 126398: 85 c0 test %eax,%eax <== NOT EXECUTED 12639a: 75 34 jne 1263d0 <== NOT EXECUTED case OBJECTS_LOCAL: _Rate_monotonic_Reset_statistics( the_period ); 12639c: 8d 7a 54 lea 0x54(%edx),%edi <== NOT EXECUTED 12639f: b9 38 00 00 00 mov $0x38,%ecx <== NOT EXECUTED 1263a4: 31 c0 xor %eax,%eax <== NOT EXECUTED 1263a6: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 1263a8: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx) <== NOT EXECUTED 1263af: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx) <== NOT EXECUTED 1263b6: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx) <== NOT EXECUTED 1263bd: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx) <== NOT EXECUTED _Thread_Enable_dispatch(); 1263c4: e8 af b3 fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 1263c9: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1263cb: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 1263ce: c9 leave <== NOT EXECUTED 1263cf: c3 ret <== NOT EXECUTED { Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 1263d0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1263d5: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 1263d8: c9 leave <== NOT EXECUTED 1263d9: c3 ret <== NOT EXECUTED 001130b8 : uint32_t length, uint32_t page_size, rtems_attribute attribute_set, Objects_Id *id ) { 1130b8: 55 push %ebp <== NOT EXECUTED 1130b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1130bb: 57 push %edi <== NOT EXECUTED 1130bc: 56 push %esi <== NOT EXECUTED 1130bd: 53 push %ebx <== NOT EXECUTED 1130be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1130c1: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1130c4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 1130c7: 85 ff test %edi,%edi <== NOT EXECUTED 1130c9: 74 25 je 1130f0 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !starting_address ) 1130cb: 85 f6 test %esi,%esi <== NOT EXECUTED 1130cd: 74 0f je 1130de <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !id ) 1130cf: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 1130d2: 85 c0 test %eax,%eax <== NOT EXECUTED 1130d4: 74 08 je 1130de <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) 1130d6: f7 c6 03 00 00 00 test $0x3,%esi <== NOT EXECUTED 1130dc: 74 22 je 113100 <== NOT EXECUTED return_status = RTEMS_SUCCESSFUL; } } _RTEMS_Unlock_allocator(); return return_status; 1130de: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED } 1130e3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1130e5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1130e8: 5b pop %ebx <== NOT EXECUTED 1130e9: 5e pop %esi <== NOT EXECUTED 1130ea: 5f pop %edi <== NOT EXECUTED 1130eb: c9 leave <== NOT EXECUTED 1130ec: c3 ret <== NOT EXECUTED 1130ed: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 1130f0: bb 03 00 00 00 mov $0x3,%ebx <== NOT EXECUTED } } _RTEMS_Unlock_allocator(); return return_status; } 1130f5: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1130f7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1130fa: 5b pop %ebx <== NOT EXECUTED 1130fb: 5e pop %esi <== NOT EXECUTED 1130fc: 5f pop %edi <== NOT EXECUTED 1130fd: c9 leave <== NOT EXECUTED 1130fe: c3 ret <== NOT EXECUTED 1130ff: 90 nop <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 113100: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113103: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113109: e8 82 23 00 00 call 115490 <_API_Mutex_Lock> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 11310e: c7 04 24 00 6c 13 00 movl $0x136c00,(%esp) <== NOT EXECUTED 113115: e8 f2 35 00 00 call 11670c <_Objects_Allocate> <== NOT EXECUTED 11311a: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_region = _Region_Allocate(); if ( !the_region ) 11311c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11311f: 85 c0 test %eax,%eax <== NOT EXECUTED 113121: 0f 84 9d 00 00 00 je 1131c4 <== NOT EXECUTED return_status = RTEMS_TOO_MANY; else { the_region->maximum_segment_size = _Heap_Initialize( 113127: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 11312a: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11312d: 56 push %esi <== NOT EXECUTED 11312e: 8d 40 68 lea 0x68(%eax),%eax <== NOT EXECUTED 113131: 50 push %eax <== NOT EXECUTED 113132: e8 01 31 00 00 call 116238 <_Heap_Initialize> <== NOT EXECUTED 113137: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED &the_region->Memory, starting_address, length, page_size ); if ( !the_region->maximum_segment_size ) { 11313a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11313d: 85 c0 test %eax,%eax <== NOT EXECUTED 11313f: 75 33 jne 113174 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 113141: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 113144: 53 push %ebx <== NOT EXECUTED 113145: 68 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 11314a: e8 7d 39 00 00 call 116acc <_Objects_Free> <== NOT EXECUTED 11314f: bb 08 00 00 00 mov $0x8,%ebx <== NOT EXECUTED 113154: 83 c4 10 add $0x10,%esp <== NOT EXECUTED *id = the_region->Object.id; return_status = RTEMS_SUCCESSFUL; } } _RTEMS_Unlock_allocator(); 113157: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11315a: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113160: e8 73 23 00 00 call 1154d8 <_API_Mutex_Unlock> <== NOT EXECUTED 113165: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 113168: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11316a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11316d: 5b pop %ebx <== NOT EXECUTED 11316e: 5e pop %esi <== NOT EXECUTED 11316f: 5f pop %edi <== NOT EXECUTED 113170: c9 leave <== NOT EXECUTED 113171: c3 ret <== NOT EXECUTED 113172: 66 90 xchg %ax,%ax <== NOT EXECUTED return_status = RTEMS_INVALID_SIZE; } else { the_region->starting_address = starting_address; 113174: 89 73 50 mov %esi,0x50(%ebx) <== NOT EXECUTED the_region->length = length; 113177: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11317a: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED the_region->page_size = page_size; 11317d: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 113180: 89 43 58 mov %eax,0x58(%ebx) <== NOT EXECUTED the_region->attribute_set = attribute_set; 113183: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 113186: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED the_region->number_of_used_blocks = 0; 113189: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) <== NOT EXECUTED _Thread_queue_Initialize( 113190: 6a 06 push $0x6 <== NOT EXECUTED 113192: 6a 40 push $0x40 <== NOT EXECUTED 113194: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED 113197: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 11319a: 50 push %eax <== NOT EXECUTED 11319b: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 11319e: 50 push %eax <== NOT EXECUTED 11319f: e8 14 4a 00 00 call 117bb8 <_Thread_queue_Initialize> <== NOT EXECUTED 1131a4: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 1131a7: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 1131aa: a1 1c 6c 13 00 mov 0x136c1c,%eax <== NOT EXECUTED 1131af: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 1131b2: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 1131b5: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 1131b8: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 1131ba: 31 db xor %ebx,%ebx <== NOT EXECUTED 1131bc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1131bf: eb 96 jmp 113157 <== NOT EXECUTED 1131c1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Allocate(); if ( !the_region ) 1131c4: b3 05 mov $0x5,%bl <== NOT EXECUTED 1131c6: eb 8f jmp 113157 <== NOT EXECUTED 001131c8 : */ rtems_status_code rtems_region_delete( Objects_Id id ) { 1131c8: 55 push %ebp <== NOT EXECUTED 1131c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1131cb: 53 push %ebx <== NOT EXECUTED 1131cc: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; _RTEMS_Lock_allocator(); 1131cf: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 1131d5: e8 b6 22 00 00 call 115490 <_API_Mutex_Lock> <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 1131da: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1131dd: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1131e0: 50 push %eax <== NOT EXECUTED 1131e1: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1131e4: 68 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 1131e9: e8 12 3a 00 00 call 116c00 <_Objects_Get_no_protection> <== NOT EXECUTED 1131ee: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 1131f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1131f3: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 1131f6: 85 c0 test %eax,%eax <== NOT EXECUTED 1131f8: 75 0e jne 113208 <== NOT EXECUTED case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks != 0 ) 1131fa: 8b 4b 64 mov 0x64(%ebx),%ecx <== NOT EXECUTED 1131fd: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1131ff: 74 2f je 113230 <== NOT EXECUTED 113201: bb 0c 00 00 00 mov $0xc,%ebx <== NOT EXECUTED 113206: eb 08 jmp 113210 <== NOT EXECUTED register Region_Control *the_region; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 113208: 48 dec %eax <== NOT EXECUTED 113209: 74 1d je 113228 <== NOT EXECUTED 11320b: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 113210: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113213: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113219: e8 ba 22 00 00 call 1154d8 <_API_Mutex_Unlock> <== NOT EXECUTED return return_status; } 11321e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 113220: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113223: c9 leave <== NOT EXECUTED 113224: c3 ret <== NOT EXECUTED 113225: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED register Region_Control *the_region; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 113228: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 11322d: eb e1 jmp 113210 <== NOT EXECUTED 11322f: 90 nop <== NOT EXECUTED case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks != 0 ) return_status = RTEMS_RESOURCE_IN_USE; else { _Objects_Close( &_Region_Information, &the_region->Object ); 113230: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 113233: 53 push %ebx <== NOT EXECUTED 113234: 68 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 113239: e8 4e 35 00 00 call 11678c <_Objects_Close> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 11323e: 58 pop %eax <== NOT EXECUTED 11323f: 5a pop %edx <== NOT EXECUTED 113240: 53 push %ebx <== NOT EXECUTED 113241: 68 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 113246: e8 81 38 00 00 call 116acc <_Objects_Free> <== NOT EXECUTED 11324b: 31 db xor %ebx,%ebx <== NOT EXECUTED 11324d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113250: eb be jmp 113210 <== NOT EXECUTED 00113254 : rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) { 113254: 55 push %ebp <== NOT EXECUTED 113255: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113257: 56 push %esi <== NOT EXECUTED 113258: 53 push %ebx <== NOT EXECUTED 113259: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 11325c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Heap_Extend_status heap_status; Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; Region_Control *the_region; if ( !starting_address ) 11325f: 85 f6 test %esi,%esi <== NOT EXECUTED 113261: 74 79 je 1132dc <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 113263: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113266: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 11326c: e8 1f 22 00 00 call 115490 <_API_Mutex_Lock> <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 113271: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 113274: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 113277: 50 push %eax <== NOT EXECUTED 113278: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11327b: 68 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 113280: e8 7b 39 00 00 call 116c00 <_Objects_Get_no_protection> <== NOT EXECUTED 113285: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 113287: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11328a: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11328d: 85 c0 test %eax,%eax <== NOT EXECUTED 11328f: 74 23 je 1132b4 <== NOT EXECUTED 113291: 48 dec %eax <== NOT EXECUTED 113292: 74 58 je 1132ec <== NOT EXECUTED switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; the_region->maximum_segment_size += amount_extended; return_status = RTEMS_SUCCESSFUL; break; 113294: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 113299: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11329c: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 1132a2: e8 31 22 00 00 call 1154d8 <_API_Mutex_Unlock> <== NOT EXECUTED 1132a7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 1132aa: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1132ac: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1132af: 5b pop %ebx <== NOT EXECUTED 1132b0: 5e pop %esi <== NOT EXECUTED 1132b1: c9 leave <== NOT EXECUTED 1132b2: c3 ret <== NOT EXECUTED 1132b3: 90 nop <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: heap_status = _Heap_Extend( 1132b4: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1132b7: 50 push %eax <== NOT EXECUTED 1132b8: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1132bb: 56 push %esi <== NOT EXECUTED 1132bc: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 1132bf: 50 push %eax <== NOT EXECUTED 1132c0: e8 9b 2c 00 00 call 115f60 <_Heap_Extend> <== NOT EXECUTED starting_address, length, &amount_extended ); switch ( heap_status ) { 1132c5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1132c8: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 1132cb: 74 27 je 1132f4 <== NOT EXECUTED 1132cd: 73 2d jae 1132fc <== NOT EXECUTED case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 1132cf: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 1132d2: 01 43 54 add %eax,0x54(%ebx) <== NOT EXECUTED the_region->maximum_segment_size += amount_extended; 1132d5: 01 43 5c add %eax,0x5c(%ebx) <== NOT EXECUTED 1132d8: 31 db xor %ebx,%ebx <== NOT EXECUTED 1132da: eb bd jmp 113299 <== NOT EXECUTED Heap_Extend_status heap_status; Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; Region_Control *the_region; if ( !starting_address ) 1132dc: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return return_status; } 1132e1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1132e3: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1132e6: 5b pop %ebx <== NOT EXECUTED 1132e7: 5e pop %esi <== NOT EXECUTED 1132e8: c9 leave <== NOT EXECUTED 1132e9: c3 ret <== NOT EXECUTED 1132ea: 66 90 xchg %ax,%ax <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Get( id, &location ); switch ( location ) { 1132ec: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 1132f1: eb a6 jmp 113299 <== NOT EXECUTED 1132f3: 90 nop <== NOT EXECUTED starting_address, length, &amount_extended ); switch ( heap_status ) { 1132f4: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED 1132f9: eb 9e jmp 113299 <== NOT EXECUTED 1132fb: 90 nop <== NOT EXECUTED 1132fc: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 1132ff: 75 93 jne 113294 <== NOT EXECUTED case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; the_region->maximum_segment_size += amount_extended; return_status = RTEMS_SUCCESSFUL; break; 113301: bb 18 00 00 00 mov $0x18,%ebx <== NOT EXECUTED 113306: eb 91 jmp 113299 <== NOT EXECUTED 00113308 : rtems_status_code rtems_region_get_free_information( Objects_Id id, Heap_Information_block *the_info ) { 113308: 55 push %ebp <== NOT EXECUTED 113309: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11330b: 53 push %ebx <== NOT EXECUTED 11330c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 11330f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !the_info ) 113312: 85 db test %ebx,%ebx <== NOT EXECUTED 113314: 74 7a je 113390 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 113316: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113319: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 11331f: e8 6c 21 00 00 call 115490 <_API_Mutex_Lock> <== NOT EXECUTED 113324: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 113327: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 11332a: 50 push %eax <== NOT EXECUTED 11332b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11332e: 68 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 113333: e8 c8 38 00 00 call 116c00 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 113338: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11333b: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 11333e: 85 d2 test %edx,%edx <== NOT EXECUTED 113340: 74 22 je 113364 <== NOT EXECUTED 113342: 4a dec %edx <== NOT EXECUTED 113343: 74 57 je 11339c <== NOT EXECUTED 113345: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 11334a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11334d: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113353: e8 80 21 00 00 call 1154d8 <_API_Mutex_Unlock> <== NOT EXECUTED 113358: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 11335b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11335d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113360: c9 leave <== NOT EXECUTED 113361: c3 ret <== NOT EXECUTED 113362: 66 90 xchg %ax,%ax <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: the_info->Used.number = 0; 113364: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED the_info->Used.total = 0; 11336b: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) <== NOT EXECUTED the_info->Used.largest = 0; 113372: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED _Heap_Get_free_information( &the_region->Memory, &the_info->Free ); 113379: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11337c: 53 push %ebx <== NOT EXECUTED 11337d: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 113380: 50 push %eax <== NOT EXECUTED 113381: e8 de 2d 00 00 call 116164 <_Heap_Get_free_information> <== NOT EXECUTED 113386: 31 db xor %ebx,%ebx <== NOT EXECUTED 113388: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11338b: eb bd jmp 11334a <== NOT EXECUTED 11338d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !the_info ) 113390: b3 09 mov $0x9,%bl <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return return_status; } 113392: 89 d8 mov %ebx,%eax <== NOT EXECUTED 113394: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113397: c9 leave <== NOT EXECUTED 113398: c3 ret <== NOT EXECUTED 113399: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 11339c: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 1133a1: eb a7 jmp 11334a <== NOT EXECUTED 001133a4 : rtems_status_code rtems_region_get_information( Objects_Id id, Heap_Information_block *the_info ) { 1133a4: 55 push %ebp <== NOT EXECUTED 1133a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1133a7: 53 push %ebx <== NOT EXECUTED 1133a8: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 1133ab: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !the_info ) 1133ae: 85 db test %ebx,%ebx <== NOT EXECUTED 1133b0: 74 6a je 11341c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 1133b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1133b5: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 1133bb: e8 d0 20 00 00 call 115490 <_API_Mutex_Lock> <== NOT EXECUTED 1133c0: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1133c3: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1133c6: 50 push %eax <== NOT EXECUTED 1133c7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1133ca: 68 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 1133cf: e8 2c 38 00 00 call 116c00 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 1133d4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1133d7: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 1133da: 85 d2 test %edx,%edx <== NOT EXECUTED 1133dc: 74 22 je 113400 <== NOT EXECUTED 1133de: 4a dec %edx <== NOT EXECUTED 1133df: 74 47 je 113428 <== NOT EXECUTED 1133e1: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 1133e6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1133e9: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 1133ef: e8 e4 20 00 00 call 1154d8 <_API_Mutex_Unlock> <== NOT EXECUTED 1133f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 1133f7: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1133f9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1133fc: c9 leave <== NOT EXECUTED 1133fd: c3 ret <== NOT EXECUTED 1133fe: 66 90 xchg %ax,%ax <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _Heap_Get_information( &the_region->Memory, the_info ) != 113400: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 113403: 53 push %ebx <== NOT EXECUTED 113404: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 113407: 50 push %eax <== NOT EXECUTED 113408: e8 9f 2d 00 00 call 1161ac <_Heap_Get_information> <== NOT EXECUTED 11340d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113410: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 113413: 19 db sbb %ebx,%ebx <== NOT EXECUTED 113415: f7 d3 not %ebx <== NOT EXECUTED 113417: 83 e3 09 and $0x9,%ebx <== NOT EXECUTED 11341a: eb ca jmp 1133e6 <== NOT EXECUTED { Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !the_info ) 11341c: b3 09 mov $0x9,%bl <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return return_status; } 11341e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 113420: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113423: c9 leave <== NOT EXECUTED 113424: c3 ret <== NOT EXECUTED 113425: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 113428: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 11342d: eb b7 jmp 1133e6 <== NOT EXECUTED 00113430 : uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 113430: 55 push %ebp <== NOT EXECUTED 113431: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113433: 57 push %edi <== NOT EXECUTED 113434: 56 push %esi <== NOT EXECUTED 113435: 53 push %ebx <== NOT EXECUTED 113436: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 113439: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11343c: 8b 5d 18 mov 0x18(%ebp),%ebx <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; void *the_segment; if ( !segment ) 11343f: 85 db test %ebx,%ebx <== NOT EXECUTED 113441: 0f 84 89 00 00 00 je 1134d0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; *segment = NULL; 113447: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED if ( size == 0 ) 11344d: 85 f6 test %esi,%esi <== NOT EXECUTED 11344f: 75 0f jne 113460 <== NOT EXECUTED 113451: bb 08 00 00 00 mov $0x8,%ebx <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return return_status; } 113456: 89 d8 mov %ebx,%eax <== NOT EXECUTED 113458: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11345b: 5b pop %ebx <== NOT EXECUTED 11345c: 5e pop %esi <== NOT EXECUTED 11345d: 5f pop %edi <== NOT EXECUTED 11345e: c9 leave <== NOT EXECUTED 11345f: c3 ret <== NOT EXECUTED *segment = NULL; if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 113460: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113463: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113469: e8 22 20 00 00 call 115490 <_API_Mutex_Lock> <== NOT EXECUTED executing = _Thread_Executing; 11346e: a1 3c 6e 13 00 mov 0x136e3c,%eax <== NOT EXECUTED 113473: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 113476: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 113479: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 11347c: 50 push %eax <== NOT EXECUTED 11347d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 113480: 68 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 113485: e8 76 37 00 00 call 116c00 <_Objects_Get_no_protection> <== NOT EXECUTED 11348a: 89 c7 mov %eax,%edi <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 11348c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11348f: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 113492: 85 c0 test %eax,%eax <== NOT EXECUTED 113494: 74 26 je 1134bc <== NOT EXECUTED 113496: 48 dec %eax <== NOT EXECUTED 113497: 74 2f je 1134c8 <== NOT EXECUTED 113499: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 11349e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1134a1: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 1134a7: e8 2c 20 00 00 call 1154d8 <_API_Mutex_Unlock> <== NOT EXECUTED 1134ac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 1134af: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1134b1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1134b4: 5b pop %ebx <== NOT EXECUTED 1134b5: 5e pop %esi <== NOT EXECUTED 1134b6: 5f pop %edi <== NOT EXECUTED 1134b7: c9 leave <== NOT EXECUTED 1134b8: c3 ret <== NOT EXECUTED 1134b9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED executing = _Thread_Executing; the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) 1134bc: 3b 77 5c cmp 0x5c(%edi),%esi <== NOT EXECUTED 1134bf: 76 13 jbe 1134d4 <== NOT EXECUTED 1134c1: bb 08 00 00 00 mov $0x8,%ebx <== NOT EXECUTED 1134c6: eb d6 jmp 11349e <== NOT EXECUTED _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 1134c8: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 1134cd: eb cf jmp 11349e <== NOT EXECUTED 1134cf: 90 nop <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; void *the_segment; if ( !segment ) 1134d0: b3 09 mov $0x9,%bl <== NOT EXECUTED 1134d2: eb 82 jmp 113456 <== NOT EXECUTED /** * This function attempts to allocate a block of @a size bytes from * @a the_heap. If insufficient memory is free in @a the_heap to allocate * a block of the requested size, then NULL is returned. * 1134d4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1134d7: 56 push %esi <== NOT EXECUTED 1134d8: 8d 47 68 lea 0x68(%edi),%eax <== NOT EXECUTED 1134db: 50 push %eax <== NOT EXECUTED 1134dc: e8 eb 29 00 00 call 115ecc <_Heap_Allocate> <== NOT EXECUTED the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 1134e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1134e4: 85 c0 test %eax,%eax <== NOT EXECUTED 1134e6: 74 09 je 1134f1 <== NOT EXECUTED the_region->number_of_used_blocks += 1; 1134e8: ff 47 64 incl 0x64(%edi) <== NOT EXECUTED *segment = the_segment; 1134eb: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 1134ed: 31 db xor %ebx,%ebx <== NOT EXECUTED 1134ef: eb ad jmp 11349e <== NOT EXECUTED return_status = RTEMS_SUCCESSFUL; } else if ( _Options_Is_no_wait( option_set ) ) { 1134f1: f6 45 10 01 testb $0x1,0x10(%ebp) <== NOT EXECUTED 1134f5: 74 07 je 1134fe <== NOT EXECUTED 1134f7: bb 0d 00 00 00 mov $0xd,%ebx <== NOT EXECUTED 1134fc: eb a0 jmp 11349e <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1134fe: a1 78 6d 13 00 mov 0x136d78,%eax <== NOT EXECUTED 113503: 40 inc %eax <== NOT EXECUTED 113504: a3 78 6d 13 00 mov %eax,0x136d78 <== NOT EXECUTED * 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(); 113509: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11350c: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113512: e8 c1 1f 00 00 call 1154d8 <_API_Mutex_Unlock> <== NOT EXECUTED executing->Wait.queue = &the_region->Wait_queue; 113517: 8d 47 10 lea 0x10(%edi),%eax <== NOT EXECUTED 11351a: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 11351d: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED executing->Wait.id = id; 113520: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 113523: 89 4a 20 mov %ecx,0x20(%edx) <== NOT EXECUTED executing->Wait.count = size; 113526: 89 72 24 mov %esi,0x24(%edx) <== NOT EXECUTED executing->Wait.return_argument = segment; 113529: 89 5a 28 mov %ebx,0x28(%edx) <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 11352c: c7 47 40 01 00 00 00 movl $0x1,0x40(%edi) <== NOT EXECUTED _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 113533: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 113536: 68 94 7c 11 00 push $0x117c94 <== NOT EXECUTED 11353b: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 11353e: 50 push %eax <== NOT EXECUTED 11353f: e8 00 44 00 00 call 117944 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 113544: e8 3b 3f 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED return (rtems_status_code) executing->Wait.return_code; 113549: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 11354c: 8b 58 34 mov 0x34(%eax),%ebx <== NOT EXECUTED 11354f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113552: e9 ff fe ff ff jmp 113456 <== NOT EXECUTED 00113558 : rtems_status_code rtems_region_get_segment_size( Objects_Id id, void *segment, size_t *size ) { 113558: 55 push %ebp <== NOT EXECUTED 113559: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11355b: 56 push %esi <== NOT EXECUTED 11355c: 53 push %ebx <== NOT EXECUTED 11355d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 113560: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 113563: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !segment ) 113566: 85 f6 test %esi,%esi <== NOT EXECUTED 113568: 74 6a je 1135d4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !size ) 11356a: 85 db test %ebx,%ebx <== NOT EXECUTED 11356c: 74 66 je 1135d4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 11356e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113571: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113577: e8 14 1f 00 00 call 115490 <_API_Mutex_Lock> <== NOT EXECUTED * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 11357c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 11357f: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 113582: 50 push %eax <== NOT EXECUTED 113583: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 113586: 68 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 11358b: e8 70 36 00 00 call 116c00 <_Objects_Get_no_protection> <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 113590: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113593: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 113596: 85 d2 test %edx,%edx <== NOT EXECUTED 113598: 74 22 je 1135bc <== NOT EXECUTED 11359a: 4a dec %edx <== NOT EXECUTED 11359b: 74 47 je 1135e4 <== NOT EXECUTED 11359d: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 1135a2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1135a5: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 1135ab: e8 28 1f 00 00 call 1154d8 <_API_Mutex_Unlock> <== NOT EXECUTED 1135b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 1135b3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1135b5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1135b8: 5b pop %ebx <== NOT EXECUTED 1135b9: 5e pop %esi <== NOT EXECUTED 1135ba: c9 leave <== NOT EXECUTED 1135bb: c3 ret <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Heap_Size_of_user_area( &the_region->Memory, segment, size ) ) 1135bc: 52 push %edx <== NOT EXECUTED 1135bd: 53 push %ebx <== NOT EXECUTED 1135be: 56 push %esi <== NOT EXECUTED 1135bf: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 1135c2: 50 push %eax <== NOT EXECUTED 1135c3: e8 44 30 00 00 call 11660c <_Heap_Size_of_user_area> <== NOT EXECUTED 1135c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1135cb: 3c 01 cmp $0x1,%al <== NOT EXECUTED 1135cd: 19 db sbb %ebx,%ebx <== NOT EXECUTED 1135cf: 83 e3 09 and $0x9,%ebx <== NOT EXECUTED 1135d2: eb ce jmp 1135a2 <== NOT EXECUTED return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); return return_status; 1135d4: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED } 1135d9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1135db: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1135de: 5b pop %ebx <== NOT EXECUTED 1135df: 5e pop %esi <== NOT EXECUTED 1135e0: c9 leave <== NOT EXECUTED 1135e1: c3 ret <== NOT EXECUTED 1135e2: 66 90 xchg %ax,%ax <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 1135e4: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 1135e9: eb b7 jmp 1135a2 <== NOT EXECUTED 001135ec : rtems_status_code rtems_region_ident( rtems_name name, Objects_Id *id ) { 1135ec: 55 push %ebp <== NOT EXECUTED 1135ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1135ef: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 1135f2: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1135f5: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 1135fa: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1135fd: 68 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 113602: e8 91 37 00 00 call 116d98 <_Objects_Name_to_id_u32> <== NOT EXECUTED 113607: 8b 04 85 74 b7 12 00 mov 0x12b774(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 11360e: c9 leave <== NOT EXECUTED 11360f: c3 ret <== NOT EXECUTED 00113610 : Objects_Id id, void *segment, size_t size, size_t *old_size ) { 113610: 55 push %ebp <== NOT EXECUTED 113611: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113613: 57 push %edi <== NOT EXECUTED 113614: 56 push %esi <== NOT EXECUTED 113615: 53 push %ebx <== NOT EXECUTED 113616: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 113619: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED uint32_t osize; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; Heap_Resize_status status; register Region_Control *the_region; if ( !old_size ) 11361c: 85 ff test %edi,%edi <== NOT EXECUTED 11361e: 0f 84 bc 00 00 00 je 1136e0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 113624: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113627: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 11362d: e8 5e 1e 00 00 call 115490 <_API_Mutex_Lock> <== NOT EXECUTED 113632: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 113635: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 113638: 50 push %eax <== NOT EXECUTED 113639: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11363c: 68 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 113641: e8 ba 35 00 00 call 116c00 <_Objects_Get_no_protection> <== NOT EXECUTED 113646: 89 c6 mov %eax,%esi <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 113648: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11364b: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11364e: 85 c0 test %eax,%eax <== NOT EXECUTED 113650: 74 2a je 11367c <== NOT EXECUTED 113652: 48 dec %eax <== NOT EXECUTED 113653: 0f 84 97 00 00 00 je 1136f0 <== NOT EXECUTED 113659: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 11365e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113661: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113667: e8 6c 1e 00 00 call 1154d8 <_API_Mutex_Unlock> <== NOT EXECUTED 11366c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 11366f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 113671: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 113674: 5b pop %ebx <== NOT EXECUTED 113675: 5e pop %esi <== NOT EXECUTED 113676: 5f pop %edi <== NOT EXECUTED 113677: c9 leave <== NOT EXECUTED 113678: c3 ret <== NOT EXECUTED 113679: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 7 ); status = _Heap_Resize_block( 11367c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11367f: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 113682: 50 push %eax <== NOT EXECUTED 113683: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 113686: 50 push %eax <== NOT EXECUTED 113687: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 11368a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11368d: 8d 46 68 lea 0x68(%esi),%eax <== NOT EXECUTED 113690: 50 push %eax <== NOT EXECUTED 113691: e8 8a 2d 00 00 call 116420 <_Heap_Resize_block> <== NOT EXECUTED 113696: 89 c3 mov %eax,%ebx <== NOT EXECUTED segment, (uint32_t) size, &osize, &avail_size ); *old_size = (uint32_t) osize; 113698: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11369b: 89 07 mov %eax,(%edi) <== NOT EXECUTED _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 ) 11369d: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1136a0: 85 db test %ebx,%ebx <== NOT EXECUTED 1136a2: 75 24 jne 1136c8 <== NOT EXECUTED 1136a4: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1136a7: 85 c0 test %eax,%eax <== NOT EXECUTED 1136a9: 75 51 jne 1136fc <== NOT EXECUTED _Region_Process_queue( the_region ); /* unlocks allocator */ else _RTEMS_Unlock_allocator(); 1136ab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1136ae: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 1136b4: e8 1f 1e 00 00 call 1154d8 <_API_Mutex_Unlock> <== NOT EXECUTED 1136b9: 31 db xor %ebx,%ebx <== NOT EXECUTED 1136bb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return return_status; } 1136be: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1136c0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1136c3: 5b pop %ebx <== NOT EXECUTED 1136c4: 5e pop %esi <== NOT EXECUTED 1136c5: 5f pop %edi <== NOT EXECUTED 1136c6: c9 leave <== NOT EXECUTED 1136c7: c3 ret <== NOT EXECUTED _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 ) _Region_Process_queue( the_region ); /* unlocks allocator */ else _RTEMS_Unlock_allocator(); 1136c8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1136cb: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 1136d1: e8 02 1e 00 00 call 1154d8 <_API_Mutex_Unlock> <== NOT EXECUTED return 1136d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1136d9: 83 fb 01 cmp $0x1,%ebx <== NOT EXECUTED 1136dc: 74 32 je 113710 <== NOT EXECUTED 1136de: 66 90 xchg %ax,%ax <== NOT EXECUTED return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); return return_status; 1136e0: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED } 1136e5: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1136e7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1136ea: 5b pop %ebx <== NOT EXECUTED 1136eb: 5e pop %esi <== NOT EXECUTED 1136ec: 5f pop %edi <== NOT EXECUTED 1136ed: c9 leave <== NOT EXECUTED 1136ee: c3 ret <== NOT EXECUTED 1136ef: 90 nop <== NOT EXECUTED if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 ) _Region_Process_queue( the_region ); /* unlocks allocator */ else _RTEMS_Unlock_allocator(); return 1136f0: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 1136f5: e9 64 ff ff ff jmp 11365e <== NOT EXECUTED 1136fa: 66 90 xchg %ax,%ax <== NOT EXECUTED *old_size = (uint32_t) osize; _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 ) _Region_Process_queue( the_region ); /* unlocks allocator */ 1136fc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1136ff: 56 push %esi <== NOT EXECUTED 113700: e8 23 72 00 00 call 11a928 <_Region_Process_queue> <== NOT EXECUTED 113705: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113708: e9 62 ff ff ff jmp 11366f <== NOT EXECUTED 11370d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED else _RTEMS_Unlock_allocator(); return 113710: b3 0d mov $0xd,%bl <== NOT EXECUTED 113712: e9 58 ff ff ff jmp 11366f <== NOT EXECUTED 00113718 : rtems_status_code rtems_region_return_segment( Objects_Id id, void *segment ) { 113718: 55 push %ebp <== NOT EXECUTED 113719: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11371b: 53 push %ebx <== NOT EXECUTED 11371c: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED uint32_t size; #endif int status; register Region_Control *the_region; _RTEMS_Lock_allocator(); 11371f: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113725: e8 66 1d 00 00 call 115490 <_API_Mutex_Lock> <== NOT EXECUTED 11372a: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 11372d: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 113730: 50 push %eax <== NOT EXECUTED 113731: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 113734: 68 00 6c 13 00 push $0x136c00 <== NOT EXECUTED 113739: e8 c2 34 00 00 call 116c00 <_Objects_Get_no_protection> <== NOT EXECUTED 11373e: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_region = _Region_Get( id, &location ); switch ( location ) { 113740: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113743: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 113746: 85 c0 test %eax,%eax <== NOT EXECUTED 113748: 75 1e jne 113768 <== NOT EXECUTED ); /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. 11374a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11374d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 113750: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 113753: 50 push %eax <== NOT EXECUTED 113754: e8 ab 28 00 00 call 116004 <_Heap_Free> <== NOT EXECUTED #endif status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) 113759: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11375c: 84 c0 test %al,%al <== NOT EXECUTED 11375e: 75 30 jne 113790 <== NOT EXECUTED else { the_region->number_of_used_blocks -= 1; _Region_Process_queue(the_region); /* unlocks allocator */ return RTEMS_SUCCESSFUL; 113760: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED 113765: eb 09 jmp 113770 <== NOT EXECUTED 113767: 90 nop <== NOT EXECUTED register Region_Control *the_region; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 113768: 48 dec %eax <== NOT EXECUTED 113769: 74 1d je 113788 <== NOT EXECUTED 11376b: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 113770: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113773: ff 35 34 6e 13 00 pushl 0x136e34 <== NOT EXECUTED 113779: e8 5a 1d 00 00 call 1154d8 <_API_Mutex_Unlock> <== NOT EXECUTED 11377e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return return_status; } 113781: 89 d8 mov %ebx,%eax <== NOT EXECUTED 113783: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113786: c9 leave <== NOT EXECUTED 113787: c3 ret <== NOT EXECUTED register Region_Control *the_region; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 113788: bb 04 00 00 00 mov $0x4,%ebx <== NOT EXECUTED 11378d: eb e1 jmp 113770 <== NOT EXECUTED 11378f: 90 nop <== NOT EXECUTED if ( !status ) return_status = RTEMS_INVALID_ADDRESS; else { the_region->number_of_used_blocks -= 1; 113790: ff 4b 64 decl 0x64(%ebx) <== NOT EXECUTED _Region_Process_queue(the_region); /* unlocks allocator */ 113793: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113796: 53 push %ebx <== NOT EXECUTED 113797: e8 8c 71 00 00 call 11a928 <_Region_Process_queue> <== NOT EXECUTED 11379c: 31 db xor %ebx,%ebx <== NOT EXECUTED 11379e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1137a1: eb de jmp 113781 <== NOT EXECUTED 0010a12c : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 10a12c: 55 push %ebp <== NOT EXECUTED 10a12d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a12f: 57 push %edi <== NOT EXECUTED 10a130: 56 push %esi <== NOT EXECUTED 10a131: 53 push %ebx <== NOT EXECUTED 10a132: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10a135: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED register Semaphore_Control *the_semaphore; CORE_mutex_Attributes the_mutex_attributes; CORE_semaphore_Attributes the_semaphore_attributes; if ( !rtems_is_name_valid( name ) ) 10a138: 85 ff test %edi,%edi <== NOT EXECUTED 10a13a: 74 64 je 10a1a0 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 10a13c: 8b 4d 18 mov 0x18(%ebp),%ecx <== NOT EXECUTED 10a13f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a141: 0f 84 01 01 00 00 je 10a248 <== NOT EXECUTED return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 10a147: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10a14a: 25 c0 00 00 00 and $0xc0,%eax <== NOT EXECUTED 10a14f: 74 1f je 10a170 <== NOT EXECUTED * @param[in] alignment the required alignment * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, 10a151: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10a154: 83 e3 30 and $0x30,%ebx <== NOT EXECUTED _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 10a157: 83 fb 10 cmp $0x10,%ebx <== NOT EXECUTED 10a15a: 74 34 je 10a190 <== NOT EXECUTED 10a15c: 83 fb 20 cmp $0x20,%ebx <== NOT EXECUTED 10a15f: 74 2f je 10a190 <== NOT EXECUTED name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 10a161: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED } 10a166: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a169: 5b pop %ebx <== NOT EXECUTED 10a16a: 5e pop %esi <== NOT EXECUTED 10a16b: 5f pop %edi <== NOT EXECUTED 10a16c: c9 leave <== NOT EXECUTED 10a16d: c3 ret <== NOT EXECUTED 10a16e: 66 90 xchg %ax,%ax <== NOT EXECUTED return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 10a170: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10a173: 83 e3 30 and $0x30,%ebx <== NOT EXECUTED 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 ) ) 10a176: 85 db test %ebx,%ebx <== NOT EXECUTED 10a178: 74 36 je 10a1b0 <== NOT EXECUTED 10a17a: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10a17e: 76 30 jbe 10a1b0 <== NOT EXECUTED 10a180: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a185: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a188: 5b pop %ebx <== NOT EXECUTED 10a189: 5e pop %esi <== NOT EXECUTED 10a18a: 5f pop %edi <== NOT EXECUTED 10a18b: c9 leave <== NOT EXECUTED 10a18c: c3 ret <== NOT EXECUTED 10a18d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 10a190: f6 45 10 04 testb $0x4,0x10(%ebp) <== NOT EXECUTED 10a194: 74 cb je 10a161 <== NOT EXECUTED _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 10a196: 3d c0 00 00 00 cmp $0xc0,%eax <== NOT EXECUTED 10a19b: 75 d9 jne 10a176 <== NOT EXECUTED 10a19d: eb c2 jmp 10a161 <== NOT EXECUTED 10a19f: 90 nop <== NOT EXECUTED { register Semaphore_Control *the_semaphore; CORE_mutex_Attributes the_mutex_attributes; CORE_semaphore_Attributes the_semaphore_attributes; if ( !rtems_is_name_valid( name ) ) 10a1a0: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a1a5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a1a8: 5b pop %ebx <== NOT EXECUTED 10a1a9: 5e pop %esi <== NOT EXECUTED 10a1aa: 5f pop %edi <== NOT EXECUTED 10a1ab: c9 leave <== NOT EXECUTED 10a1ac: c3 ret <== NOT EXECUTED 10a1ad: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a1b0: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10a1b5: 40 inc %eax <== NOT EXECUTED 10a1b6: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10a1bb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a1be: 68 00 f7 11 00 push $0x11f700 <== NOT EXECUTED 10a1c3: e8 4c 14 00 00 call 10b614 <_Objects_Allocate> <== NOT EXECUTED 10a1c8: 89 c6 mov %eax,%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 10a1ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a1cd: 85 c0 test %eax,%eax <== NOT EXECUTED 10a1cf: 0f 84 eb 00 00 00 je 10a2c0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_semaphore->attribute_set = attribute_set; 10a1d5: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10a1d8: 89 46 10 mov %eax,0x10(%esi) <== NOT EXECUTED * 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 ) ) { 10a1db: 85 db test %ebx,%ebx <== NOT EXECUTED 10a1dd: 74 75 je 10a254 <== NOT EXECUTED CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) 10a1df: a8 40 test $0x40,%al <== NOT EXECUTED 10a1e1: 0f 84 c5 00 00 00 je 10a2ac <== NOT EXECUTED the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 10a1e7: c7 45 e4 02 00 00 00 movl $0x2,-0x1c(%ebp) <== NOT EXECUTED the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; else the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 10a1ee: 83 fb 10 cmp $0x10,%ebx <== NOT EXECUTED 10a1f1: 0f 84 d9 00 00 00 je 10a2d0 <== NOT EXECUTED 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; 10a1f7: c7 45 dc 02 00 00 00 movl $0x2,-0x24(%ebp) <== NOT EXECUTED the_mutex_attributes.only_owner_release = FALSE; 10a1fe: c6 45 e0 00 movb $0x0,-0x20(%ebp) <== NOT EXECUTED } the_mutex_attributes.priority_ceiling = priority_ceiling; 10a202: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a205: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED mutex_status = _CORE_mutex_Initialize( 10a208: 52 push %edx <== NOT EXECUTED 10a209: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a20b: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) <== NOT EXECUTED 10a20f: 0f 94 c0 sete %al <== NOT EXECUTED 10a212: 50 push %eax <== NOT EXECUTED 10a213: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 10a216: 50 push %eax <== NOT EXECUTED 10a217: 8d 46 14 lea 0x14(%esi),%eax <== NOT EXECUTED 10a21a: 50 push %eax <== NOT EXECUTED 10a21b: e8 44 0d 00 00 call 10af64 <_CORE_mutex_Initialize> <== NOT EXECUTED &the_semaphore->Core_control.mutex, &the_mutex_attributes, (count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED ); if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) { 10a220: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a223: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 10a226: 75 61 jne 10a289 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 10a228: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a22b: 56 push %esi <== NOT EXECUTED 10a22c: 68 00 f7 11 00 push $0x11f700 <== NOT EXECUTED 10a231: e8 9e 17 00 00 call 10b9d4 <_Objects_Free> <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 10a236: e8 11 21 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a23b: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED 10a240: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a243: e9 1e ff ff ff jmp 10a166 <== NOT EXECUTED CORE_semaphore_Attributes the_semaphore_attributes; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 10a248: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a24d: e9 14 ff ff ff jmp 10a166 <== NOT EXECUTED 10a252: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INVALID_PRIORITY; } } else { if ( _Attributes_Is_priority( attribute_set ) ) the_semaphore_attributes.discipline = CORE_SEMAPHORE_DISCIPLINES_PRIORITY; 10a254: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a256: f6 45 10 04 testb $0x4,0x10(%ebp) <== NOT EXECUTED 10a25a: 0f 95 c0 setne %al <== NOT EXECUTED 10a25d: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 10a260: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp) <== NOT EXECUTED /* * The following are just to make Purify happy. */ the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 10a267: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; 10a26e: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp) <== NOT EXECUTED _CORE_semaphore_Initialize( 10a275: 50 push %eax <== NOT EXECUTED 10a276: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a279: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10a27c: 50 push %eax <== NOT EXECUTED 10a27d: 8d 46 14 lea 0x14(%esi),%eax <== NOT EXECUTED 10a280: 50 push %eax <== NOT EXECUTED 10a281: e8 96 0f 00 00 call 10b21c <_CORE_semaphore_Initialize> <== NOT EXECUTED 10a286: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a289: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED 10a28c: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10a28f: a1 1c f7 11 00 mov 0x11f71c,%eax <== NOT EXECUTED 10a294: 89 34 90 mov %esi,(%eax,%edx,4) <== NOT EXECUTED 10a297: 89 7e 0c mov %edi,0xc(%esi) <== NOT EXECUTED &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 10a29a: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10a29d: 89 08 mov %ecx,(%eax) <== NOT EXECUTED the_semaphore->Object.id, name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 10a29f: e8 a8 20 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a2a4: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a2a6: e9 bb fe ff ff jmp 10a166 <== NOT EXECUTED 10a2ab: 90 nop <== NOT EXECUTED 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 ) ) 10a2ac: 80 7d 10 00 cmpb $0x0,0x10(%ebp) <== NOT EXECUTED 10a2b0: 79 43 jns 10a2f5 <== NOT EXECUTED the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 10a2b2: c7 45 e4 03 00 00 00 movl $0x3,-0x1c(%ebp) <== NOT EXECUTED 10a2b9: e9 30 ff ff ff jmp 10a1ee <== NOT EXECUTED 10a2be: 66 90 xchg %ax,%ax <== NOT EXECUTED _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { _Thread_Enable_dispatch(); 10a2c0: e8 87 20 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a2c5: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10a2ca: e9 97 fe ff ff jmp 10a166 <== NOT EXECUTED 10a2cf: 90 nop <== NOT EXECUTED else the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 10a2d0: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED switch ( the_mutex_attributes.discipline ) { 10a2d7: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10a2da: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10a2dd: 0f 86 1b ff ff ff jbe 10a1fe <== NOT EXECUTED 10a2e3: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10a2e6: 0f 87 16 ff ff ff ja 10a202 <== NOT EXECUTED case CORE_MUTEX_DISCIPLINES_PRIORITY: the_mutex_attributes.only_owner_release = FALSE; break; case CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING: case CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT: the_mutex_attributes.only_owner_release = TRUE; 10a2ec: c6 45 e0 01 movb $0x1,-0x20(%ebp) <== NOT EXECUTED 10a2f0: e9 0d ff ff ff jmp 10a202 <== NOT EXECUTED 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 ) ) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; 10a2f5: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a2f7: f6 45 10 04 testb $0x4,0x10(%ebp) <== NOT EXECUTED 10a2fb: 0f 95 c0 setne %al <== NOT EXECUTED 10a2fe: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED 10a301: e9 e8 fe ff ff jmp 10a1ee <== NOT EXECUTED 0010a308 : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 10a308: 55 push %ebp <== NOT EXECUTED 10a309: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a30b: 53 push %ebx <== NOT EXECUTED 10a30c: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap 10a30f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a312: 50 push %eax <== NOT EXECUTED 10a313: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a316: 68 00 f7 11 00 push $0x11f700 <== NOT EXECUTED 10a31b: e8 e8 17 00 00 call 10bb08 <_Objects_Get> <== NOT EXECUTED 10a320: 89 c3 mov %eax,%ebx <== NOT EXECUTED register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 10a322: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a325: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 10a328: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a32a: 74 0c je 10a338 <== NOT EXECUTED 10a32c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a331: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a334: c9 leave <== NOT EXECUTED 10a335: c3 ret <== NOT EXECUTED 10a336: 66 90 xchg %ax,%ax <== NOT EXECUTED ); /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * 10a338: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10a33b: 83 e0 30 and $0x30,%eax <== NOT EXECUTED 10a33e: 74 58 je 10a398 <== NOT EXECUTED if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 10a340: 8b 53 64 mov 0x64(%ebx),%edx <== NOT EXECUTED 10a343: 85 d2 test %edx,%edx <== NOT EXECUTED 10a345: 75 15 jne 10a35c <== NOT EXECUTED 10a347: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED 10a34a: 74 10 je 10a35c <== NOT EXECUTED !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); 10a34c: e8 fb 1f 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a351: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a356: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a359: c9 leave <== NOT EXECUTED 10a35a: c3 ret <== NOT EXECUTED 10a35b: 90 nop <== NOT EXECUTED !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } _CORE_mutex_Flush( 10a35c: 50 push %eax <== NOT EXECUTED 10a35d: 6a 04 push $0x4 <== NOT EXECUTED 10a35f: 6a 00 push $0x0 <== NOT EXECUTED 10a361: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 10a364: 50 push %eax <== NOT EXECUTED 10a365: e8 ee 0b 00 00 call 10af58 <_CORE_mutex_Flush> <== NOT EXECUTED 10a36a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_SEMAPHORE_WAS_DELETED ); } _Objects_Close( &_Semaphore_Information, &the_semaphore->Object ); 10a36d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a370: 53 push %ebx <== NOT EXECUTED 10a371: 68 00 f7 11 00 push $0x11f700 <== NOT EXECUTED 10a376: e8 19 13 00 00 call 10b694 <_Objects_Close> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 10a37b: 58 pop %eax <== NOT EXECUTED 10a37c: 5a pop %edx <== NOT EXECUTED 10a37d: 53 push %ebx <== NOT EXECUTED 10a37e: 68 00 f7 11 00 push $0x11f700 <== NOT EXECUTED 10a383: e8 4c 16 00 00 call 10b9d4 <_Objects_Free> <== NOT EXECUTED 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 10a388: e8 bf 1f 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a38d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a38f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a392: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a395: c9 leave <== NOT EXECUTED 10a396: c3 ret <== NOT EXECUTED 10a397: 90 nop <== NOT EXECUTED &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 10a398: 51 push %ecx <== NOT EXECUTED 10a399: 6a 02 push $0x2 <== NOT EXECUTED 10a39b: 6a 00 push $0x0 <== NOT EXECUTED 10a39d: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 10a3a0: 50 push %eax <== NOT EXECUTED 10a3a1: e8 6a 0e 00 00 call 10b210 <_CORE_semaphore_Flush> <== NOT EXECUTED 10a3a6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a3a9: eb c2 jmp 10a36d <== NOT EXECUTED 0012643c : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 12643c: 55 push %ebp <== NOT EXECUTED 12643d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12643f: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED * to add to the heap 126442: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 126445: 50 push %eax <== NOT EXECUTED 126446: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126449: 68 40 1e 16 00 push $0x161e40 <== NOT EXECUTED 12644e: e8 31 aa fe ff call 110e84 <_Objects_Get> <== NOT EXECUTED register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 126453: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126456: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 126459: 85 d2 test %edx,%edx <== NOT EXECUTED 12645b: 74 07 je 126464 <== NOT EXECUTED 12645d: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126462: c9 leave <== NOT EXECUTED 126463: c3 ret <== NOT EXECUTED the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 126464: f6 40 10 30 testb $0x30,0x10(%eax) <== NOT EXECUTED 126468: 75 1a jne 126484 <== NOT EXECUTED &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 12646a: 52 push %edx <== NOT EXECUTED 12646b: 6a 01 push $0x1 <== NOT EXECUTED 12646d: 6a 00 push $0x0 <== NOT EXECUTED 12646f: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 126472: 50 push %eax <== NOT EXECUTED 126473: e8 b4 9f fe ff call 11042c <_CORE_semaphore_Flush> <== NOT EXECUTED 126478: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &the_semaphore->Core_control.semaphore, SEND_OBJECT_WAS_DELETED, CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT ); } _Thread_Enable_dispatch(); 12647b: e8 f8 b2 fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 126480: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126482: c9 leave <== NOT EXECUTED 126483: c3 ret <== NOT EXECUTED the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Flush( 126484: 51 push %ecx <== NOT EXECUTED 126485: 6a 01 push $0x1 <== NOT EXECUTED 126487: 6a 00 push $0x0 <== NOT EXECUTED 126489: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 12648c: 50 push %eax <== NOT EXECUTED 12648d: e8 e2 9c fe ff call 110174 <_CORE_mutex_Flush> <== NOT EXECUTED 126492: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126495: eb e4 jmp 12647b <== NOT EXECUTED 00113a80 : rtems_status_code rtems_semaphore_ident( rtems_name name, uint32_t node, rtems_id *id ) { 113a80: 55 push %ebp <== NOT EXECUTED 113a81: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113a83: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( &_Semaphore_Information, name, node, id ); 113a86: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 113a89: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 113a8c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 113a8f: 68 40 6c 13 00 push $0x136c40 <== NOT EXECUTED 113a94: e8 ff 32 00 00 call 116d98 <_Objects_Name_to_id_u32> <== NOT EXECUTED 113a99: 8b 04 85 74 b7 12 00 mov 0x12b774(,%eax,4),%eax <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; } 113aa0: c9 leave <== NOT EXECUTED 113aa1: c3 ret <== NOT EXECUTED 0010a3ac : rtems_status_code rtems_semaphore_obtain( rtems_id id, rtems_option option_set, rtems_interval timeout ) { 10a3ac: 55 push %ebp <== NOT EXECUTED 10a3ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a3af: 56 push %esi <== NOT EXECUTED 10a3b0: 53 push %ebx <== NOT EXECUTED 10a3b1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10a3b4: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size 10a3b7: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10a3ba: 50 push %eax <== NOT EXECUTED 10a3bb: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10a3be: 50 push %eax <== NOT EXECUTED 10a3bf: 53 push %ebx <== NOT EXECUTED 10a3c0: 68 00 f7 11 00 push $0x11f700 <== NOT EXECUTED 10a3c5: e8 f2 16 00 00 call 10babc <_Objects_Get_isr_disable> <== NOT EXECUTED 10a3ca: 89 c2 mov %eax,%edx <== NOT EXECUTED register Semaphore_Control *the_semaphore; Objects_Locations location; ISR_Level level; the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { 10a3cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a3cf: 8b 4d f4 mov -0xc(%ebp),%ecx <== NOT EXECUTED 10a3d2: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a3d4: 74 0e je 10a3e4 <== NOT EXECUTED 10a3d6: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED break; } return RTEMS_INVALID_ID; } 10a3db: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a3de: 5b pop %ebx <== NOT EXECUTED 10a3df: 5e pop %esi <== NOT EXECUTED 10a3e0: c9 leave <== NOT EXECUTED 10a3e1: c3 ret <== NOT EXECUTED 10a3e2: 66 90 xchg %ax,%ax <== NOT EXECUTED the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10a3e4: f6 40 10 30 testb $0x30,0x10(%eax) <== NOT EXECUTED 10a3e8: 74 3a je 10a424 <== NOT EXECUTED _CORE_mutex_Seize( 10a3ea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a3ed: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10a3f0: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a3f3: 83 75 0c 01 xorl $0x1,0xc(%ebp) <== NOT EXECUTED 10a3f7: 83 65 0c 01 andl $0x1,0xc(%ebp) <== NOT EXECUTED 10a3fb: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a3fe: 53 push %ebx <== NOT EXECUTED 10a3ff: 8d 40 14 lea 0x14(%eax),%eax <== NOT EXECUTED 10a402: 50 push %eax <== NOT EXECUTED 10a403: e8 54 0c 00 00 call 10b05c <_CORE_mutex_Seize> <== NOT EXECUTED id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 10a408: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10a40b: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED 10a410: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10a413: e8 0c 01 00 00 call 10a524 <_Semaphore_Translate_core_mutex_return_code> <== NOT EXECUTED 10a418: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } return RTEMS_INVALID_ID; } 10a41b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a41e: 5b pop %ebx <== NOT EXECUTED 10a41f: 5e pop %esi <== NOT EXECUTED 10a420: c9 leave <== NOT EXECUTED 10a421: c3 ret <== NOT EXECUTED 10a422: 66 90 xchg %ax,%ax <== NOT EXECUTED /** * This function attempts to allocate a block of @a size bytes from * @a the_heap. If insufficient memory is free in @a the_heap to allocate * a block of the requested size, then NULL is returned. * * @param[in] the_heap is the heap to operate upon 10a424: 8b 75 f0 mov -0x10(%ebp),%esi <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate( 10a427: 8b 0d 7c f8 11 00 mov 0x11f87c,%ecx <== NOT EXECUTED Heap_Control *the_heap, 10a42d: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) <== NOT EXECUTED size_t size 10a434: 8b 40 5c mov 0x5c(%eax),%eax <== NOT EXECUTED 10a437: 85 c0 test %eax,%eax <== NOT EXECUTED 10a439: 75 29 jne 10a464 <== NOT EXECUTED ); /** * This function attempts to allocate a memory block of @a size bytes from * @a the_heap so that the start of the user memory is aligned on the * @a alignment boundary. If @a alignment is 0, it is set to CPU_ALIGNMENT. 10a43b: f6 45 0c 01 testb $0x1,0xc(%ebp) <== NOT EXECUTED 10a43f: 74 2b je 10a46c <== NOT EXECUTED * Any other value of @a alignment is taken "as is", i.e., even odd 10a441: 56 push %esi <== NOT EXECUTED 10a442: 9d popf <== NOT EXECUTED * alignments are possible. 10a443: c7 41 34 01 00 00 00 movl $0x1,0x34(%ecx) <== NOT EXECUTED id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 10a44a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a44d: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED 10a452: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10a455: e8 da 00 00 00 call 10a534 <_Semaphore_Translate_core_semaphore_return_code> <== NOT EXECUTED 10a45a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } return RTEMS_INVALID_ID; } 10a45d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a460: 5b pop %ebx <== NOT EXECUTED 10a461: 5e pop %esi <== NOT EXECUTED 10a462: c9 leave <== NOT EXECUTED 10a463: c3 ret <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); 10a464: 48 dec %eax <== NOT EXECUTED 10a465: 89 42 5c mov %eax,0x5c(%edx) <== NOT EXECUTED 10a468: 56 push %esi <== NOT EXECUTED 10a469: 9d popf <== NOT EXECUTED 10a46a: eb de jmp 10a44a <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a46c: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10a471: 40 inc %eax <== NOT EXECUTED 10a472: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10a477: c7 42 44 01 00 00 00 movl $0x1,0x44(%edx) <== NOT EXECUTED * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @param[in] alignment the required alignment 10a47e: 8d 42 14 lea 0x14(%edx),%eax <== NOT EXECUTED 10a481: 89 41 44 mov %eax,0x44(%ecx) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10a484: 89 59 20 mov %ebx,0x20(%ecx) <== NOT EXECUTED */ 10a487: 56 push %esi <== NOT EXECUTED 10a488: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, 10a489: 52 push %edx <== NOT EXECUTED 10a48a: 68 5c cb 10 00 push $0x10cb5c <== NOT EXECUTED 10a48f: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a492: 50 push %eax <== NOT EXECUTED 10a493: e8 74 23 00 00 call 10c80c <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED size_t size, 10a498: e8 af 1e 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a49d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a4a0: eb a8 jmp 10a44a <== NOT EXECUTED 0010a4a4 : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 10a4a4: 55 push %ebp <== NOT EXECUTED 10a4a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4a7: 53 push %ebx <== NOT EXECUTED 10a4a8: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10a4ab: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon * @param[in] starting_address is the starting address of the memory * to add to the heap 10a4ae: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a4b1: 50 push %eax <== NOT EXECUTED 10a4b2: 53 push %ebx <== NOT EXECUTED 10a4b3: 68 00 f7 11 00 push $0x11f700 <== NOT EXECUTED 10a4b8: e8 4b 16 00 00 call 10bb08 <_Objects_Get> <== NOT EXECUTED Objects_Locations location; CORE_mutex_Status mutex_status; CORE_semaphore_Status semaphore_status; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 10a4bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a4c0: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10a4c3: 85 d2 test %edx,%edx <== NOT EXECUTED 10a4c5: 74 0d je 10a4d4 <== NOT EXECUTED 10a4c7: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a4cc: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a4cf: c9 leave <== NOT EXECUTED 10a4d0: c3 ret <== NOT EXECUTED 10a4d1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10a4d4: f6 40 10 30 testb $0x30,0x10(%eax) <== NOT EXECUTED 10a4d8: 75 26 jne 10a500 <== NOT EXECUTED MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); } else { semaphore_status = _CORE_semaphore_Surrender( 10a4da: 52 push %edx <== NOT EXECUTED 10a4db: 6a 00 push $0x0 <== NOT EXECUTED 10a4dd: 53 push %ebx <== NOT EXECUTED 10a4de: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 10a4e1: 50 push %eax <== NOT EXECUTED 10a4e2: e8 75 0d 00 00 call 10b25c <_CORE_semaphore_Surrender> <== NOT EXECUTED 10a4e7: 89 c3 mov %eax,%ebx <== NOT EXECUTED &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 10a4e9: e8 5e 1e 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED return 10a4ee: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a4f1: e8 3e 00 00 00 call 10a534 <_Semaphore_Translate_core_semaphore_return_code> <== NOT EXECUTED 10a4f6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a4f9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a4fc: c9 leave <== NOT EXECUTED 10a4fd: c3 ret <== NOT EXECUTED 10a4fe: 66 90 xchg %ax,%ax <== NOT EXECUTED the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { mutex_status = _CORE_mutex_Surrender( 10a500: 51 push %ecx <== NOT EXECUTED 10a501: 6a 00 push $0x0 <== NOT EXECUTED 10a503: 53 push %ebx <== NOT EXECUTED 10a504: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 10a507: 50 push %eax <== NOT EXECUTED 10a508: e8 eb 0b 00 00 call 10b0f8 <_CORE_mutex_Surrender> <== NOT EXECUTED 10a50d: 89 c3 mov %eax,%ebx <== NOT EXECUTED &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 10a50f: e8 38 1e 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED return _Semaphore_Translate_core_mutex_return_code( mutex_status ); 10a514: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a517: e8 08 00 00 00 call 10a524 <_Semaphore_Translate_core_mutex_return_code> <== NOT EXECUTED 10a51c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a51f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a522: c9 leave <== NOT EXECUTED 10a523: c3 ret <== NOT EXECUTED 001172e8 : */ void rtems_shutdown_executive( uint32_t result ) { 1172e8: 55 push %ebp <== NOT EXECUTED 1172e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1172eb: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 1172ee: 83 3d 84 f9 11 00 04 cmpl $0x4,0x11f984 <== NOT EXECUTED 1172f5: 74 1e je 117315 <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 1172f7: c7 05 84 f9 11 00 04 movl $0x4,0x11f984 <== NOT EXECUTED 1172fe: 00 00 00 <== NOT EXECUTED #endif } /** * This routine sets the current system state to that specified by * the called. 117301: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 117304: 68 a0 f7 11 00 push $0x11f7a0 <== NOT EXECUTED 117309: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 11730c: 50 push %eax <== NOT EXECUTED 11730d: e8 0e 62 ff ff call 10d520 <_CPU_Context_switch> <== NOT EXECUTED 117312: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_SHUTDOWN ); _Thread_Stop_multitasking(); } } 117315: c9 leave <== NOT EXECUTED 117316: c3 ret <== NOT EXECUTED 0010b1e0 : rtems_status_code rtems_signal_catch( rtems_asr_entry asr_handler, rtems_mode mode_set ) { 10b1e0: 55 push %ebp <== NOT EXECUTED 10b1e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b1e3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b1e6: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED RTEMS_API_Control *api; ASR_Information *asr; /* XXX normalize mode */ executing = _Thread_Executing; api = (RTEMS_API_Control*)executing->API_Extensions[ THREAD_API_RTEMS ]; 10b1e9: a1 9c 34 12 00 mov 0x12349c,%eax <== NOT EXECUTED 10b1ee: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10b1f4: a1 d8 33 12 00 mov 0x1233d8,%eax <== NOT EXECUTED 10b1f9: 40 inc %eax <== NOT EXECUTED 10b1fa: a3 d8 33 12 00 mov %eax,0x1233d8 <== NOT EXECUTED asr = &api->Signal; _Thread_Disable_dispatch(); /* cannot reschedule while */ /* the thread is inconsistent */ if ( !_ASR_Is_null_handler( asr_handler ) ) { 10b1ff: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b201: 74 15 je 10b218 <== NOT EXECUTED asr->mode_set = mode_set; 10b203: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b206: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED asr->handler = asr_handler; 10b209: 89 4a 0c mov %ecx,0xc(%edx) <== NOT EXECUTED } else _ASR_Initialize( asr ); _Thread_Enable_dispatch(); 10b20c: e8 af 21 00 00 call 10d3c0 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10b211: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b213: c9 leave <== NOT EXECUTED 10b214: c3 ret <== NOT EXECUTED 10b215: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED #endif /** * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of 10b218: c6 42 08 01 movb $0x1,0x8(%edx) <== NOT EXECUTED * @a page_size byte units. If @a page_size is 0 or is not multiple of 10b21c: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) <== NOT EXECUTED * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 10b223: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED * 10b22a: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10b231: c7 42 18 00 00 00 00 movl $0x0,0x18(%edx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10b238: c7 42 1c 00 00 00 00 movl $0x0,0x1c(%edx) <== NOT EXECUTED asr->mode_set = mode_set; asr->handler = asr_handler; } else _ASR_Initialize( asr ); _Thread_Enable_dispatch(); 10b23f: e8 7c 21 00 00 call 10d3c0 <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10b244: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b246: c9 leave <== NOT EXECUTED 10b247: c3 ret <== NOT EXECUTED 00113c3c : rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) { 113c3c: 55 push %ebp <== NOT EXECUTED 113c3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 113c3f: 53 push %ebx <== NOT EXECUTED 113c40: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 113c43: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 113c46: 85 db test %ebx,%ebx <== NOT EXECUTED 113c48: 75 0a jne 113c54 <== NOT EXECUTED 113c4a: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 113c4f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113c52: c9 leave <== NOT EXECUTED 113c53: c3 ret <== NOT EXECUTED ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 113c54: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 113c57: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 113c5a: 50 push %eax <== NOT EXECUTED 113c5b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 113c5e: e8 45 38 00 00 call 1174a8 <_Thread_Get> <== NOT EXECUTED 113c63: 89 c1 mov %eax,%ecx <== NOT EXECUTED switch ( location ) { 113c65: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 113c68: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 113c6b: 85 d2 test %edx,%edx <== NOT EXECUTED 113c6d: 74 0d je 113c7c <== NOT EXECUTED 113c6f: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 113c74: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113c77: c9 leave <== NOT EXECUTED 113c78: c3 ret <== NOT EXECUTED 113c79: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 113c7c: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx <== NOT EXECUTED asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 113c82: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 113c85: 85 c0 test %eax,%eax <== NOT EXECUTED 113c87: 74 43 je 113ccc <== NOT EXECUTED if ( asr->is_enabled ) { 113c89: 80 7a 08 00 cmpb $0x0,0x8(%edx) <== NOT EXECUTED 113c8d: 74 29 je 113cb8 <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 113c8f: 9c pushf <== NOT EXECUTED 113c90: fa cli <== NOT EXECUTED 113c91: 58 pop %eax <== NOT EXECUTED ); 113c92: 09 5a 14 or %ebx,0x14(%edx) <== NOT EXECUTED 113c95: 50 push %eax <== NOT EXECUTED 113c96: 9d popf <== NOT EXECUTED _ASR_Post_signals( signal_set, &asr->signals_posted ); the_thread->do_post_task_switch_extension = true; 113c97: c6 41 75 01 movb $0x1,0x75(%ecx) <== NOT EXECUTED if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 113c9b: a1 18 6e 13 00 mov 0x136e18,%eax <== NOT EXECUTED 113ca0: 85 c0 test %eax,%eax <== NOT EXECUTED 113ca2: 74 1c je 113cc0 <== NOT EXECUTED 113ca4: 3b 0d 3c 6e 13 00 cmp 0x136e3c,%ecx <== NOT EXECUTED 113caa: 75 14 jne 113cc0 <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 113cac: c6 05 e8 6e 13 00 01 movb $0x1,0x136ee8 <== NOT EXECUTED 113cb3: eb 0b jmp 113cc0 <== NOT EXECUTED 113cb5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 113cb8: 9c pushf <== NOT EXECUTED 113cb9: fa cli <== NOT EXECUTED 113cba: 58 pop %eax <== NOT EXECUTED ); 113cbb: 09 5a 18 or %ebx,0x18(%edx) <== NOT EXECUTED 113cbe: 50 push %eax <== NOT EXECUTED 113cbf: 9d popf <== NOT EXECUTED } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 113cc0: e8 bf 37 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 113cc5: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 113cc7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 113cca: c9 leave <== NOT EXECUTED 113ccb: c3 ret <== NOT EXECUTED _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 113ccc: e8 b3 37 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 113cd1: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED 113cd6: e9 74 ff ff ff jmp 113c4f <== NOT EXECUTED 001095d0 : * rtems_stack_checker_Begin_extension */ void rtems_stack_checker_begin_extension( Thread_Control *the_thread ) { 1095d0: 55 push %ebp <== NOT EXECUTED 1095d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1095d3: 57 push %edi <== NOT EXECUTED 1095d4: 56 push %esi <== NOT EXECUTED 1095d5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED Stack_check_Control *the_pattern; if ( the_thread->Object.id == 0 ) /* skip system tasks */ 1095d8: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 1095db: 85 d2 test %edx,%edx <== NOT EXECUTED 1095dd: 74 15 je 1095f4 <== NOT EXECUTED return; the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack); *the_pattern = Stack_check_Pattern; 1095df: 8b 80 c8 00 00 00 mov 0xc8(%eax),%eax <== NOT EXECUTED 1095e5: 8d 78 08 lea 0x8(%eax),%edi <== NOT EXECUTED 1095e8: be 40 1d 16 00 mov $0x161d40,%esi <== NOT EXECUTED 1095ed: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1095f2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED } 1095f4: 5e pop %esi <== NOT EXECUTED 1095f5: 5f pop %edi <== NOT EXECUTED 1095f6: c9 leave <== NOT EXECUTED 1095f7: c3 ret <== NOT EXECUTED 001099b8 : */ bool rtems_stack_checker_create_extension( Thread_Control *running, Thread_Control *the_thread ) { 1099b8: 55 push %ebp <== NOT EXECUTED 1099b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099bb: 57 push %edi <== NOT EXECUTED 1099bc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1099bf: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Stack_check_Initialize(); 1099c2: e8 81 ff ff ff call 109948 <== NOT EXECUTED if (the_thread) 1099c7: 85 ff test %edi,%edi <== NOT EXECUTED 1099c9: 74 10 je 1099db <== NOT EXECUTED Stack_check_Dope_stack(&the_thread->Start.Initial_stack); 1099cb: 8b 8f c4 00 00 00 mov 0xc4(%edi),%ecx <== NOT EXECUTED 1099d1: 8b bf c8 00 00 00 mov 0xc8(%edi),%edi <== NOT EXECUTED 1099d7: b0 a5 mov $0xa5,%al <== NOT EXECUTED 1099d9: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED return true; } 1099db: b0 01 mov $0x1,%al <== NOT EXECUTED 1099dd: 5a pop %edx <== NOT EXECUTED 1099de: 5f pop %edi <== NOT EXECUTED 1099df: c9 leave <== NOT EXECUTED 1099e0: c3 ret <== NOT EXECUTED 0010985c : /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) { 10985c: 55 push %ebp <== NOT EXECUTED 10985d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10985f: 57 push %edi <== NOT EXECUTED 109860: 56 push %esi <== NOT EXECUTED 109861: 53 push %ebx <== NOT EXECUTED 109862: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 109865: a1 bc 1f 16 00 mov 0x161fbc,%eax <== NOT EXECUTED ) { void *sp = __builtin_frame_address(0); #if defined(__GNUC__) if ( sp < the_stack->area ) { 10986a: 8b 90 c8 00 00 00 mov 0xc8(%eax),%edx <== NOT EXECUTED 109870: 39 d5 cmp %edx,%ebp <== NOT EXECUTED 109872: 73 38 jae 1098ac <== NOT EXECUTED 109874: 31 db xor %ebx,%ebx <== NOT EXECUTED /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 109876: 8b 35 70 eb 14 00 mov 0x14eb70,%esi <== NOT EXECUTED 10987c: 85 f6 test %esi,%esi <== NOT EXECUTED 10987e: 75 44 jne 1098c4 <== NOT EXECUTED 109880: b0 01 mov $0x1,%al <== NOT EXECUTED } /* * The Stack Pointer and the Pattern Area are OK so return false. */ if ( sp_ok && pattern_ok ) 109882: 84 db test %bl,%bl <== NOT EXECUTED 109884: 74 04 je 10988a <== NOT EXECUTED 109886: 84 c0 test %al,%al <== NOT EXECUTED 109888: 75 4e jne 1098d8 <== NOT EXECUTED return false; /* * Let's report as much as we can. */ Stack_check_report_blown_task( _Thread_Executing, pattern_ok ); 10988a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10988d: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 109890: 50 push %eax <== NOT EXECUTED 109891: ff 35 bc 1f 16 00 pushl 0x161fbc <== NOT EXECUTED 109897: e8 54 ff ff ff call 1097f0 <== NOT EXECUTED 10989c: b0 01 mov $0x1,%al <== NOT EXECUTED 10989e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return true; } 1098a1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1098a4: 5b pop %ebx <== NOT EXECUTED 1098a5: 5e pop %esi <== NOT EXECUTED 1098a6: 5f pop %edi <== NOT EXECUTED 1098a7: c9 leave <== NOT EXECUTED 1098a8: c3 ret <== NOT EXECUTED 1098a9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { void *sp = __builtin_frame_address(0); #if defined(__GNUC__) if ( sp < the_stack->area ) { 1098ac: 8b 88 c4 00 00 00 mov 0xc4(%eax),%ecx <== NOT EXECUTED 1098b2: 8d 04 0a lea (%edx,%ecx,1),%eax <== NOT EXECUTED 1098b5: 39 c5 cmp %eax,%ebp <== NOT EXECUTED 1098b7: 0f 96 c3 setbe %bl <== NOT EXECUTED /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 1098ba: 8b 35 70 eb 14 00 mov 0x14eb70,%esi <== NOT EXECUTED 1098c0: 85 f6 test %esi,%esi <== NOT EXECUTED 1098c2: 74 bc je 109880 <== NOT EXECUTED pattern_ok = (!memcmp( 1098c4: 8d 72 08 lea 0x8(%edx),%esi <== NOT EXECUTED 1098c7: bf 40 1d 16 00 mov $0x161d40,%edi <== NOT EXECUTED 1098cc: b9 10 00 00 00 mov $0x10,%ecx <== NOT EXECUTED 1098d1: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 1098d3: 0f 94 c0 sete %al <== NOT EXECUTED 1098d6: eb aa jmp 109882 <== NOT EXECUTED } /* * The Stack Pointer and the Pattern Area are OK so return false. */ if ( sp_ok && pattern_ok ) 1098d8: 31 c0 xor %eax,%eax <== NOT EXECUTED /* * Let's report as much as we can. */ Stack_check_report_blown_task( _Thread_Executing, pattern_ok ); return true; } 1098da: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1098dd: 5b pop %ebx <== NOT EXECUTED 1098de: 5e pop %esi <== NOT EXECUTED 1098df: 5f pop %edi <== NOT EXECUTED 1098e0: c9 leave <== NOT EXECUTED 1098e1: c3 ret <== NOT EXECUTED 001097d8 : void rtems_stack_checker_report_usage( void ) { 1097d8: 55 push %ebp <== NOT EXECUTED 1097d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1097db: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin ); 1097de: 68 8c c7 10 00 push $0x10c78c <== NOT EXECUTED 1097e3: 6a 00 push $0x0 <== NOT EXECUTED 1097e5: e8 8a ff ff ff call 109774 <== NOT EXECUTED 1097ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1097ed: c9 leave <== NOT EXECUTED 1097ee: c3 ret <== NOT EXECUTED 00109774 : void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) { 109774: 55 push %ebp <== NOT EXECUTED 109775: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109777: 56 push %esi <== NOT EXECUTED 109778: 53 push %ebx <== NOT EXECUTED 109779: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10977c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED print_context = context; 10977f: 89 1d 74 eb 14 00 mov %ebx,0x14eb74 <== NOT EXECUTED print_handler = print; 109785: 89 35 78 eb 14 00 mov %esi,0x14eb78 <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 10978b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10978e: 68 e1 1d 14 00 push $0x141de1 <== NOT EXECUTED 109793: 53 push %ebx <== NOT EXECUTED 109794: ff d6 call *%esi <== NOT EXECUTED (*print)( context, 109796: 58 pop %eax <== NOT EXECUTED 109797: 5a pop %edx <== NOT EXECUTED 109798: 68 f8 1d 14 00 push $0x141df8 <== NOT EXECUTED 10979d: 53 push %ebx <== NOT EXECUTED 10979e: ff d6 call *%esi <== NOT EXECUTED " ID NAME LOW HIGH CURRENT AVAILABLE USED\n" ); /* iterate over all threads and dump the usage */ rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage ); 1097a0: c7 04 24 34 96 10 00 movl $0x109634,(%esp) <== NOT EXECUTED 1097a7: e8 84 70 00 00 call 110830 <== NOT EXECUTED /* dump interrupt stack info if any */ Stack_check_Dump_threads_usage((Thread_Control *) -1); 1097ac: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED 1097b3: e8 7c fe ff ff call 109634 <== NOT EXECUTED print_context = NULL; 1097b8: c7 05 74 eb 14 00 00 movl $0x0,0x14eb74 <== NOT EXECUTED 1097bf: 00 00 00 <== NOT EXECUTED print_handler = NULL; 1097c2: c7 05 78 eb 14 00 00 movl $0x0,0x14eb78 <== NOT EXECUTED 1097c9: 00 00 00 <== NOT EXECUTED 1097cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1097cf: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1097d2: 5b pop %ebx <== NOT EXECUTED 1097d3: 5e pop %esi <== NOT EXECUTED 1097d4: c9 leave <== NOT EXECUTED 1097d5: c3 ret <== NOT EXECUTED 001098e4 : */ void rtems_stack_checker_switch_extension( Thread_Control *running, Thread_Control *heir ) { 1098e4: 55 push %ebp <== NOT EXECUTED 1098e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1098e7: 57 push %edi <== NOT EXECUTED 1098e8: 56 push %esi <== NOT EXECUTED 1098e9: 53 push %ebx <== NOT EXECUTED 1098ea: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1098ed: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Stack_Control *the_stack = &running->Start.Initial_stack; void *pattern; bool sp_ok; bool pattern_ok = true; pattern = (void *) Stack_check_Get_pattern_area(the_stack)->pattern; 1098f0: 8b 83 c8 00 00 00 mov 0xc8(%ebx),%eax <== NOT EXECUTED 1098f6: 8d 70 08 lea 0x8(%eax),%esi <== NOT EXECUTED ) { void *sp = __builtin_frame_address(0); #if defined(__GNUC__) if ( sp < the_stack->area ) { 1098f9: 39 c5 cmp %eax,%ebp <== NOT EXECUTED 1098fb: 72 0a jb 109907 <== NOT EXECUTED return false; } if ( sp > (the_stack->area + the_stack->size) ) { 1098fd: 03 83 c4 00 00 00 add 0xc4(%ebx),%eax <== NOT EXECUTED 109903: 39 c5 cmp %eax,%ebp <== NOT EXECUTED 109905: 76 25 jbe 10992c <== 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, 109907: bf 40 1d 16 00 mov $0x161d40,%edi <== NOT EXECUTED 10990c: b9 10 00 00 00 mov $0x10,%ecx <== NOT EXECUTED 109911: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 109913: 0f 94 c0 sete %al <== NOT EXECUTED (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { Stack_check_report_blown_task( running, pattern_ok ); 109916: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 109919: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10991c: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 10991f: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 109922: 5b pop %ebx <== NOT EXECUTED 109923: 5e pop %esi <== NOT EXECUTED 109924: 5f pop %edi <== NOT EXECUTED 109925: c9 leave <== NOT EXECUTED pattern_ok = (!memcmp( pattern, (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { Stack_check_report_blown_task( running, pattern_ok ); 109926: e9 c5 fe ff ff jmp 1097f0 <== NOT EXECUTED 10992b: 90 nop <== 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, 10992c: bf 40 1d 16 00 mov $0x161d40,%edi <== NOT EXECUTED 109931: b9 10 00 00 00 mov $0x10,%ecx <== NOT EXECUTED (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { 109936: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 109938: 74 06 je 109940 <== NOT EXECUTED 10993a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10993c: eb d8 jmp 109916 <== NOT EXECUTED 10993e: 66 90 xchg %ax,%ax <== NOT EXECUTED Stack_check_report_blown_task( running, pattern_ok ); } } 109940: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 109943: 5b pop %ebx <== NOT EXECUTED 109944: 5e pop %esi <== NOT EXECUTED 109945: 5f pop %edi <== NOT EXECUTED 109946: c9 leave <== NOT EXECUTED 109947: c3 ret <== NOT EXECUTED 0010b6b8 : const char * rtems_status_text( rtems_status_code status ) { 10b6b8: 55 push %ebp <== NOT EXECUTED 10b6b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b6bb: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return rtems_assoc_name_by_local(rtems_status_assoc, status); 10b6be: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b6c1: 68 c0 46 12 00 push $0x1246c0 <== NOT EXECUTED 10b6c6: e8 b5 96 00 00 call 114d80 <== NOT EXECUTED } 10b6cb: c9 leave <== NOT EXECUTED 10b6cc: c3 ret <== NOT EXECUTED 0010a544 : size_t stack_size, rtems_mode initial_modes, rtems_attribute attribute_set, Objects_Id *id ) { 10a544: 55 push %ebp <== NOT EXECUTED 10a545: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a547: 57 push %edi <== NOT EXECUTED 10a548: 56 push %esi <== NOT EXECUTED 10a549: 53 push %ebx <== NOT EXECUTED 10a54a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a54d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10a550: 8b 5d 18 mov 0x18(%ebp),%ebx <== NOT EXECUTED Priority_Control core_priority; RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) 10a553: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 10a556: 85 c0 test %eax,%eax <== NOT EXECUTED 10a558: 0f 84 32 01 00 00 je 10a690 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10a55e: 85 ff test %edi,%edi <== NOT EXECUTED 10a560: 0f 84 c2 00 00 00 je 10a628 <== NOT EXECUTED /* * Validate the RTEMS API priority and convert it to the core priority range. */ if ( !_Attributes_Is_system_task( the_attribute_set ) ) { 10a566: 66 85 db test %bx,%bx <== NOT EXECUTED 10a569: 78 1b js 10a586 <== NOT EXECUTED bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ); 10a56b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a56e: 85 c0 test %eax,%eax <== NOT EXECUTED 10a570: 0f 84 f2 00 00 00 je 10a668 <== NOT EXECUTED 10a576: 0f b6 05 d4 b1 11 00 movzbl 0x11b1d4,%eax <== NOT EXECUTED 10a57d: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 10a580: 0f 87 e2 00 00 00 ja 10a668 <== NOT EXECUTED */ /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10a586: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a589: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10a58f: e8 d4 07 00 00 call 10ad68 <_API_Mutex_Lock> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10a594: c7 04 24 40 f7 11 00 movl $0x11f740,(%esp) <== NOT EXECUTED 10a59b: e8 74 10 00 00 call 10b614 <_Objects_Allocate> <== NOT EXECUTED 10a5a0: 89 c6 mov %eax,%esi <== NOT EXECUTED * the event of an error. */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { 10a5a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a5a5: 85 c0 test %eax,%eax <== NOT EXECUTED 10a5a7: 0f 84 cb 00 00 00 je 10a678 <== NOT EXECUTED /* * Initialize the core thread for this task. */ status = _Thread_Initialize( 10a5ad: 50 push %eax <== NOT EXECUTED 10a5ae: 57 push %edi <== NOT EXECUTED 10a5af: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a5b2: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10a5b5: 50 push %eax <== NOT EXECUTED 10a5b6: 6a 00 push $0x0 <== NOT EXECUTED 10a5b8: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a5bb: c1 e8 09 shr $0x9,%eax <== NOT EXECUTED 10a5be: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10a5c1: 50 push %eax <== NOT EXECUTED 10a5c2: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10a5c5: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 10a5c8: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 10a5cb: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10a5ce: 50 push %eax <== NOT EXECUTED 10a5cf: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a5d2: 83 e3 01 and $0x1,%ebx <== NOT EXECUTED 10a5d5: 53 push %ebx <== NOT EXECUTED 10a5d6: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a5d9: 6a 00 push $0x0 <== NOT EXECUTED 10a5db: 56 push %esi <== NOT EXECUTED 10a5dc: 68 40 f7 11 00 push $0x11f740 <== NOT EXECUTED 10a5e1: e8 0a 1e 00 00 call 10c3f0 <_Thread_Initialize> <== NOT EXECUTED NULL, /* no budget algorithm callout */ _Modes_Get_interrupt_level(initial_modes), (Objects_Name) name ); if ( !status ) { 10a5e6: 83 c4 30 add $0x30,%esp <== NOT EXECUTED 10a5e9: 84 c0 test %al,%al <== NOT EXECUTED 10a5eb: 74 4b je 10a638 <== NOT EXECUTED } api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true; 10a5ed: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax <== NOT EXECUTED 10a5f3: c1 6d 14 0a shrl $0xa,0x14(%ebp) <== NOT EXECUTED 10a5f7: 83 75 14 01 xorl $0x1,0x14(%ebp) <== NOT EXECUTED 10a5fb: 8a 55 14 mov 0x14(%ebp),%dl <== NOT EXECUTED 10a5fe: 83 e2 01 and $0x1,%edx <== NOT EXECUTED 10a601: 88 50 08 mov %dl,0x8(%eax) <== NOT EXECUTED *id = the_thread->Object.id; 10a604: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10a607: 8b 55 1c mov 0x1c(%ebp),%edx <== NOT EXECUTED 10a60a: 89 02 mov %eax,(%edx) <== NOT EXECUTED ); } #endif _RTEMS_Unlock_allocator(); 10a60c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a60f: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10a615: e8 96 07 00 00 call 10adb0 <_API_Mutex_Unlock> <== NOT EXECUTED 10a61a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a61c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10a61f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a622: 5b pop %ebx <== NOT EXECUTED 10a623: 5e pop %esi <== NOT EXECUTED 10a624: 5f pop %edi <== NOT EXECUTED 10a625: c9 leave <== NOT EXECUTED 10a626: c3 ret <== NOT EXECUTED 10a627: 90 nop <== NOT EXECUTED if ( !id ) return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10a628: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10a62d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a630: 5b pop %ebx <== NOT EXECUTED 10a631: 5e pop %esi <== NOT EXECUTED 10a632: 5f pop %edi <== NOT EXECUTED 10a633: c9 leave <== NOT EXECUTED 10a634: c3 ret <== NOT EXECUTED 10a635: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 10a638: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a63b: ff 76 08 pushl 0x8(%esi) <== NOT EXECUTED 10a63e: e8 05 14 00 00 call 10ba48 <_Objects_Get_information_id> <== NOT EXECUTED 10a643: 5a pop %edx <== NOT EXECUTED 10a644: 59 pop %ecx <== NOT EXECUTED 10a645: 56 push %esi <== NOT EXECUTED 10a646: 50 push %eax <== NOT EXECUTED 10a647: e8 88 13 00 00 call 10b9d4 <_Objects_Free> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( is_global ) _Objects_MP_Free_global_object( the_global_object ); #endif _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 10a64c: 58 pop %eax <== NOT EXECUTED 10a64d: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10a653: e8 58 07 00 00 call 10adb0 <_API_Mutex_Unlock> <== NOT EXECUTED 10a658: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 10a65d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10a660: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a663: 5b pop %ebx <== NOT EXECUTED 10a664: 5e pop %esi <== NOT EXECUTED 10a665: 5f pop %edi <== NOT EXECUTED 10a666: c9 leave <== NOT EXECUTED 10a667: c3 ret <== NOT EXECUTED } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; 10a668: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED } 10a66d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a670: 5b pop %ebx <== NOT EXECUTED 10a671: 5e pop %esi <== NOT EXECUTED 10a672: 5f pop %edi <== NOT EXECUTED 10a673: c9 leave <== NOT EXECUTED 10a674: c3 ret <== NOT EXECUTED 10a675: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { _RTEMS_Unlock_allocator(); 10a678: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a67b: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10a681: e8 2a 07 00 00 call 10adb0 <_API_Mutex_Unlock> <== NOT EXECUTED 10a686: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10a68b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a68e: eb 9d jmp 10a62d <== NOT EXECUTED Priority_Control core_priority; RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) 10a690: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a695: eb 96 jmp 10a62d <== NOT EXECUTED 0010a698 : */ rtems_status_code rtems_task_delete( Objects_Id id ) { 10a698: 55 push %ebp <== NOT EXECUTED 10a699: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a69b: 53 push %ebx <== NOT EXECUTED 10a69c: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; _RTEMS_Lock_allocator(); 10a69f: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10a6a5: e8 be 06 00 00 call 10ad68 <_API_Mutex_Lock> <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); 10a6aa: 58 pop %eax <== NOT EXECUTED 10a6ab: 5a pop %edx <== NOT EXECUTED 10a6ac: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a6af: 50 push %eax <== NOT EXECUTED 10a6b0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a6b3: e8 b8 1c 00 00 call 10c370 <_Thread_Get> <== NOT EXECUTED 10a6b8: 89 c3 mov %eax,%ebx <== NOT EXECUTED switch ( location ) { 10a6ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a6bd: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10a6c0: 85 c0 test %eax,%eax <== NOT EXECUTED 10a6c2: 75 44 jne 10a708 <== NOT EXECUTED case OBJECTS_LOCAL: the_information = _Objects_Get_information_id( the_thread->Object.id ); 10a6c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a6c7: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a6ca: e8 79 13 00 00 call 10ba48 <_Objects_Get_information_id> <== NOT EXECUTED 0 /* Not used */ ); } #endif _Thread_Close( the_information, the_thread ); 10a6cf: 5a pop %edx <== NOT EXECUTED 10a6d0: 59 pop %ecx <== NOT EXECUTED 10a6d1: 53 push %ebx <== NOT EXECUTED 10a6d2: 50 push %eax <== NOT EXECUTED 10a6d3: e8 58 19 00 00 call 10c030 <_Thread_Close> <== NOT EXECUTED 10a6d8: 58 pop %eax <== NOT EXECUTED 10a6d9: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a6dc: e8 67 13 00 00 call 10ba48 <_Objects_Get_information_id> <== NOT EXECUTED 10a6e1: 5a pop %edx <== NOT EXECUTED 10a6e2: 59 pop %ecx <== NOT EXECUTED 10a6e3: 53 push %ebx <== NOT EXECUTED 10a6e4: 50 push %eax <== NOT EXECUTED 10a6e5: e8 ea 12 00 00 call 10b9d4 <_Objects_Free> <== NOT EXECUTED _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 10a6ea: 58 pop %eax <== NOT EXECUTED 10a6eb: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10a6f1: e8 ba 06 00 00 call 10adb0 <_API_Mutex_Unlock> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a6f6: e8 51 1c 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a6fb: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a6fd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; } 10a700: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a703: c9 leave <== NOT EXECUTED 10a704: c3 ret <== NOT EXECUTED 10a705: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED case OBJECTS_ERROR: break; } _RTEMS_Unlock_allocator(); 10a708: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a70b: ff 35 74 f8 11 00 pushl 0x11f874 <== NOT EXECUTED 10a711: e8 9a 06 00 00 call 10adb0 <_API_Mutex_Unlock> <== NOT EXECUTED 10a716: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10a71b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_INVALID_ID; } 10a71e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a721: c9 leave <== NOT EXECUTED 10a722: c3 ret <== NOT EXECUTED 0010bdf0 : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 10bdf0: 55 push %ebp <== NOT EXECUTED 10bdf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bdf3: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10bdf6: a1 b4 4b 12 00 mov 0x124bb4,%eax <== NOT EXECUTED 10bdfb: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10bdfe: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10be02: 74 64 je 10be68 <== NOT EXECUTED return RTEMS_NOT_CONFIGURED; if ( !note ) 10be04: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10be07: 85 c0 test %eax,%eax <== NOT EXECUTED 10be09: 0f 84 85 00 00 00 je 10be94 <== NOT EXECUTED /* * 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 ) 10be0f: 83 7d 0c 0f cmpl $0xf,0xc(%ebp) <== NOT EXECUTED 10be13: 77 4b ja 10be60 <== NOT EXECUTED /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10be15: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10be18: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10be1a: 74 54 je 10be70 <== NOT EXECUTED 10be1c: a1 dc 4b 12 00 mov 0x124bdc,%eax <== NOT EXECUTED 10be21: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10be24: 3b 50 08 cmp 0x8(%eax),%edx <== NOT EXECUTED 10be27: 74 4c je 10be75 <== NOT EXECUTED api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10be29: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10be2c: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10be2f: 50 push %eax <== NOT EXECUTED 10be30: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10be33: e8 8c 1f 00 00 call 10ddc4 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10be38: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10be3b: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10be3e: 85 d2 test %edx,%edx <== NOT EXECUTED 10be40: 75 4a jne 10be8c <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10be42: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10be48: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10be4b: 8b 44 90 20 mov 0x20(%eax,%edx,4),%eax <== NOT EXECUTED 10be4f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10be52: 89 02 mov %eax,(%edx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10be54: e8 47 1f 00 00 call 10dda0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10be59: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be5b: c9 leave <== NOT EXECUTED 10be5c: c3 ret <== NOT EXECUTED 10be5d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * 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 ) 10be60: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be65: c9 leave <== NOT EXECUTED 10be66: c3 ret <== NOT EXECUTED 10be67: 90 nop <== NOT EXECUTED { register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10be68: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be6d: c9 leave <== NOT EXECUTED 10be6e: c3 ret <== NOT EXECUTED 10be6f: 90 nop <== NOT EXECUTED 10be70: a1 dc 4b 12 00 mov 0x124bdc,%eax <== NOT EXECUTED */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10be75: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10be7b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10be7e: 8b 44 90 20 mov 0x20(%eax,%edx,4),%eax <== NOT EXECUTED 10be82: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10be85: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10be87: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be89: c9 leave <== NOT EXECUTED 10be8a: c3 ret <== NOT EXECUTED 10be8b: 90 nop <== NOT EXECUTED *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 10be8c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be91: c9 leave <== NOT EXECUTED 10be92: c3 ret <== NOT EXECUTED 10be93: 90 nop <== NOT EXECUTED RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; if ( !note ) 10be94: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be99: c9 leave <== NOT EXECUTED 10be9a: c3 ret <== NOT EXECUTED 0010a724 : rtems_status_code rtems_task_ident( rtems_name name, uint32_t node, Objects_Id *id ) { 10a724: 55 push %ebp <== NOT EXECUTED 10a725: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a727: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a72a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10a72d: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; if ( !id ) 10a730: 85 d2 test %edx,%edx <== NOT EXECUTED 10a732: 74 30 je 10a764 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( name == OBJECTS_ID_OF_SELF ) { 10a734: 85 c0 test %eax,%eax <== NOT EXECUTED 10a736: 75 10 jne 10a748 <== NOT EXECUTED *id = _Thread_Executing->Object.id; 10a738: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED 10a73d: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10a740: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10a742: 31 c0 xor %eax,%eax <== NOT EXECUTED } status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id ); return _Status_Object_name_errors_to_status[ status ]; } 10a744: c9 leave <== NOT EXECUTED 10a745: c3 ret <== NOT EXECUTED 10a746: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( name == OBJECTS_ID_OF_SELF ) { *id = _Thread_Executing->Object.id; return RTEMS_SUCCESSFUL; } status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id ); 10a748: 52 push %edx <== NOT EXECUTED 10a749: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a74c: 50 push %eax <== NOT EXECUTED 10a74d: 68 40 f7 11 00 push $0x11f740 <== NOT EXECUTED 10a752: e8 09 15 00 00 call 10bc60 <_Objects_Name_to_id_u32> <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; 10a757: 8b 04 85 d4 90 11 00 mov 0x1190d4(,%eax,4),%eax <== NOT EXECUTED 10a75e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10a761: c9 leave <== NOT EXECUTED 10a762: c3 ret <== NOT EXECUTED 10a763: 90 nop <== NOT EXECUTED Objects_Id *id ) { Objects_Name_or_id_lookup_errors status; if ( !id ) 10a764: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id ); return _Status_Object_name_errors_to_status[ status ]; } 10a769: c9 leave <== NOT EXECUTED 10a76a: c3 ret <== NOT EXECUTED 0010acd8 : */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) { 10acd8: 55 push %ebp <== NOT EXECUTED 10acd9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10acdb: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10acde: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10ace1: 50 push %eax <== NOT EXECUTED 10ace2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ace5: e8 8e 1c 00 00 call 10c978 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10acea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aced: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10acf0: 85 d2 test %edx,%edx <== NOT EXECUTED 10acf2: 74 08 je 10acfc <== NOT EXECUTED 10acf4: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10acf9: c9 leave <== NOT EXECUTED 10acfa: c3 ret <== NOT EXECUTED 10acfb: 90 nop <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 10acfc: f6 40 10 02 testb $0x2,0x10(%eax) <== NOT EXECUTED 10ad00: 74 0e je 10ad10 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10ad02: e8 4d 1c 00 00 call 10c954 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ad07: b8 0f 00 00 00 mov $0xf,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ad0c: c9 leave <== NOT EXECUTED 10ad0d: c3 ret <== NOT EXECUTED 10ad0e: 66 90 xchg %ax,%ax <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { _Thread_Enable_dispatch(); 10ad10: e8 3f 1c 00 00 call 10c954 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ad15: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ad17: c9 leave <== NOT EXECUTED 10ad18: c3 ret <== NOT EXECUTED 0011078c : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 11078c: 55 push %ebp <== NOT EXECUTED 11078d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11078f: 57 push %edi <== NOT EXECUTED 110790: 56 push %esi <== NOT EXECUTED 110791: 53 push %ebx <== NOT EXECUTED 110792: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110795: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED ASR_Information *asr; bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) 110798: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 11079b: 85 c9 test %ecx,%ecx <== NOT EXECUTED 11079d: 0f 84 31 01 00 00 je 1108d4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 1107a3: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED 1107a8: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED api = executing->API_Extensions[ THREAD_API_RTEMS ]; 1107ab: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx <== NOT EXECUTED 1107b1: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 1107b4: 80 78 76 01 cmpb $0x1,0x76(%eax) <== NOT EXECUTED 1107b8: 19 f6 sbb %esi,%esi <== NOT EXECUTED 1107ba: 81 e6 00 01 00 00 and $0x100,%esi <== NOT EXECUTED if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 1107c0: 8b 50 7c mov 0x7c(%eax),%edx <== NOT EXECUTED 1107c3: 85 d2 test %edx,%edx <== NOT EXECUTED 1107c5: 0f 85 bd 00 00 00 jne 110888 <== NOT EXECUTED old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 1107cb: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 1107ce: 80 7b 08 01 cmpb $0x1,0x8(%ebx) <== NOT EXECUTED 1107d2: 19 db sbb %ebx,%ebx <== NOT EXECUTED 1107d4: 81 e3 00 04 00 00 and $0x400,%ebx <== NOT EXECUTED old_mode |= _ISR_Get_level(); 1107da: e8 1d cf ff ff call 10d6fc <_CPU_ISR_Get_level> <== NOT EXECUTED if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 1107df: 09 c3 or %eax,%ebx <== NOT EXECUTED old_mode |= _ISR_Get_level(); *previous_mode_set = old_mode; 1107e1: 09 f3 or %esi,%ebx <== NOT EXECUTED 1107e3: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1107e6: 89 18 mov %ebx,(%eax) <== NOT EXECUTED /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 1107e8: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) <== NOT EXECUTED 1107ef: 74 11 je 110802 <== NOT EXECUTED executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE; 1107f1: 89 f8 mov %edi,%eax <== NOT EXECUTED 1107f3: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 1107f6: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 1107f9: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 1107fc: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 1107ff: 88 42 76 mov %al,0x76(%edx) <== NOT EXECUTED if ( mask & RTEMS_TIMESLICE_MASK ) { 110802: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) <== NOT EXECUTED 110809: 74 1e je 110829 <== NOT EXECUTED if ( _Modes_Is_timeslice(mode_set) ) { 11080b: f7 c7 00 02 00 00 test $0x200,%edi <== NOT EXECUTED 110811: 0f 84 81 00 00 00 je 110898 <== NOT EXECUTED executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 110817: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 11081a: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 110821: a1 84 f7 11 00 mov 0x11f784,%eax <== NOT EXECUTED 110826: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 110829: f6 45 0c 01 testb $0x1,0xc(%ebp) <== NOT EXECUTED 11082d: 74 09 je 110838 <== NOT EXECUTED * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @param[in] alignment the required alignment 11082f: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED 110835: 74 5d je 110894 <== NOT EXECUTED 110837: fa cli <== NOT EXECUTED */ is_asr_enabled = FALSE; needs_asr_dispatching = FALSE; if ( mask & RTEMS_ASR_MASK ) { 110838: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) <== NOT EXECUTED 11083f: 74 31 je 110872 <== NOT EXECUTED 110841: c1 ef 0a shr $0xa,%edi <== NOT EXECUTED 110844: 83 f7 01 xor $0x1,%edi <== NOT EXECUTED 110847: 89 f8 mov %edi,%eax <== NOT EXECUTED 110849: 83 e0 01 and $0x1,%eax <== NOT EXECUTED is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true; if ( is_asr_enabled != asr->is_enabled ) { 11084c: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 11084f: 38 42 08 cmp %al,0x8(%edx) <== NOT EXECUTED 110852: 74 1e je 110872 <== NOT EXECUTED asr->is_enabled = is_asr_enabled; 110854: 88 42 08 mov %al,0x8(%edx) <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 110857: 9c pushf <== NOT EXECUTED 110858: fa cli <== NOT EXECUTED 110859: 59 pop %ecx <== NOT EXECUTED /** 11085a: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 11085d: 8b 53 18 mov 0x18(%ebx),%edx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 110860: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 110863: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED * begin at @a starting_address. 110866: 89 53 14 mov %edx,0x14(%ebx) <== NOT EXECUTED * 110869: 51 push %ecx <== NOT EXECUTED 11086a: 9d popf <== NOT EXECUTED _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { 11086b: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 11086e: 85 c0 test %eax,%eax <== NOT EXECUTED 110870: 75 56 jne 1108c8 <== NOT EXECUTED needs_asr_dispatching = true; executing->do_post_task_switch_extension = true; 110872: 31 db xor %ebx,%ebx <== NOT EXECUTED } } } if ( _System_state_Is_up(_System_state_Current) ) 110874: 83 3d 84 f9 11 00 03 cmpl $0x3,0x11f984 <== NOT EXECUTED 11087b: 74 2f je 1108ac <== NOT EXECUTED if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) _Thread_Dispatch(); 11087d: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 11087f: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 110882: 5b pop %ebx <== NOT EXECUTED 110883: 5e pop %esi <== NOT EXECUTED 110884: 5f pop %edi <== NOT EXECUTED 110885: c9 leave <== NOT EXECUTED 110886: c3 ret <== NOT EXECUTED 110887: 90 nop <== NOT EXECUTED old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; 110888: 81 ce 00 02 00 00 or $0x200,%esi <== NOT EXECUTED 11088e: e9 38 ff ff ff jmp 1107cb <== NOT EXECUTED 110893: 90 nop <== NOT EXECUTED * Returns pointer to the start of the memory block if success, NULL if * failure. * * @param[in] the_heap is the heap to operate upon * @param[in] size is the amount of memory to allocate in bytes * @param[in] alignment the required alignment 110894: fb sti <== NOT EXECUTED 110895: eb a1 jmp 110838 <== NOT EXECUTED 110897: 90 nop <== NOT EXECUTED if ( mask & RTEMS_TIMESLICE_MASK ) { if ( _Modes_Is_timeslice(mode_set) ) { executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; executing->cpu_time_budget = _Thread_Ticks_per_timeslice; } else executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 110898: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11089b: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%eax) <== NOT EXECUTED /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 1108a2: f6 45 0c 01 testb $0x1,0xc(%ebp) <== NOT EXECUTED 1108a6: 74 90 je 110838 <== NOT EXECUTED 1108a8: eb 85 jmp 11082f <== NOT EXECUTED 1108aa: 66 90 xchg %ax,%ax <== NOT EXECUTED } } } if ( _System_state_Is_up(_System_state_Current) ) if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) 1108ac: e8 73 01 00 00 call 110a24 <_Thread_Evaluate_mode> <== NOT EXECUTED 1108b1: 84 c0 test %al,%al <== NOT EXECUTED 1108b3: 75 04 jne 1108b9 <== NOT EXECUTED 1108b5: 84 db test %bl,%bl <== NOT EXECUTED 1108b7: 74 c4 je 11087d <== NOT EXECUTED _Thread_Dispatch(); 1108b9: e8 32 b9 ff ff call 10c1f0 <_Thread_Dispatch> <== NOT EXECUTED 1108be: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 1108c0: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1108c3: 5b pop %ebx <== NOT EXECUTED 1108c4: 5e pop %esi <== NOT EXECUTED 1108c5: 5f pop %edi <== NOT EXECUTED 1108c6: c9 leave <== NOT EXECUTED 1108c7: c3 ret <== NOT EXECUTED if ( is_asr_enabled != asr->is_enabled ) { asr->is_enabled = is_asr_enabled; _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { needs_asr_dispatching = true; executing->do_post_task_switch_extension = true; 1108c8: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1108cb: c6 40 75 01 movb $0x1,0x75(%eax) <== NOT EXECUTED 1108cf: b3 01 mov $0x1,%bl <== NOT EXECUTED 1108d1: eb a1 jmp 110874 <== NOT EXECUTED 1108d3: 90 nop <== NOT EXECUTED ASR_Information *asr; bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) 1108d4: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED if ( _System_state_Is_up(_System_state_Current) ) if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) _Thread_Dispatch(); return RTEMS_SUCCESSFUL; } 1108d9: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1108dc: 5b pop %ebx <== NOT EXECUTED 1108dd: 5e pop %esi <== NOT EXECUTED 1108de: 5f pop %edi <== NOT EXECUTED 1108df: c9 leave <== NOT EXECUTED 1108e0: c3 ret <== NOT EXECUTED 0010b0f8 : rtems_status_code rtems_task_restart( Objects_Id id, uint32_t argument ) { 10b0f8: 55 push %ebp <== NOT EXECUTED 10b0f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b0fb: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10b0fe: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b101: 50 push %eax <== NOT EXECUTED 10b102: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b105: e8 8e 1c 00 00 call 10cd98 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10b10a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b10d: 8b 4d fc mov -0x4(%ebp),%ecx <== NOT EXECUTED 10b110: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b112: 75 20 jne 10b134 <== NOT EXECUTED case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { 10b114: 52 push %edx <== NOT EXECUTED 10b115: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b118: 6a 00 push $0x0 <== NOT EXECUTED 10b11a: 50 push %eax <== NOT EXECUTED 10b11b: e8 9c 24 00 00 call 10d5bc <_Thread_Restart> <== NOT EXECUTED 10b120: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b123: 84 c0 test %al,%al <== NOT EXECUTED 10b125: 75 15 jne 10b13c <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10b127: e8 48 1c 00 00 call 10cd74 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b12c: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b131: c9 leave <== NOT EXECUTED 10b132: c3 ret <== NOT EXECUTED 10b133: 90 nop <== NOT EXECUTED { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 10b134: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b139: c9 leave <== NOT EXECUTED 10b13a: c3 ret <== NOT EXECUTED 10b13b: 90 nop <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { _Thread_Enable_dispatch(); 10b13c: e8 33 1c 00 00 call 10cd74 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b141: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b143: c9 leave <== NOT EXECUTED 10b144: c3 ret <== NOT EXECUTED 0010b930 : */ rtems_status_code rtems_task_resume( Objects_Id id ) { 10b930: 55 push %ebp <== NOT EXECUTED 10b931: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b933: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10b936: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b939: 50 push %eax <== NOT EXECUTED 10b93a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b93d: e8 26 1f 00 00 call 10d868 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10b942: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b945: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10b948: 85 d2 test %edx,%edx <== NOT EXECUTED 10b94a: 74 08 je 10b954 <== NOT EXECUTED 10b94c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b951: c9 leave <== NOT EXECUTED 10b952: c3 ret <== NOT EXECUTED 10b953: 90 nop <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 10b954: f6 40 10 02 testb $0x2,0x10(%eax) <== NOT EXECUTED 10b958: 75 0e jne 10b968 <== NOT EXECUTED _Thread_Resume( the_thread, TRUE ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10b95a: e8 b9 1e 00 00 call 10d818 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b95f: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b964: c9 leave <== NOT EXECUTED 10b965: c3 ret <== NOT EXECUTED 10b966: 66 90 xchg %ax,%ax <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { _Thread_Resume( the_thread, TRUE ); 10b968: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b96b: 6a 01 push $0x1 <== NOT EXECUTED 10b96d: 50 push %eax <== NOT EXECUTED 10b96e: e8 19 27 00 00 call 10e08c <_Thread_Resume> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b973: e8 a0 1e 00 00 call 10d818 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b978: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b97a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b97d: c9 leave <== NOT EXECUTED 10b97e: c3 ret <== NOT EXECUTED 00126664 : #include #include rtems_id rtems_task_self(void) { 126664: 55 push %ebp <== NOT EXECUTED 126665: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126667: a1 bc 1f 16 00 mov 0x161fbc,%eax <== NOT EXECUTED 12666c: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED return _Thread_Executing->Object.id; } 12666f: c9 leave <== NOT EXECUTED 126670: c3 ret <== NOT EXECUTED 0010bf74 : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 10bf74: 55 push %ebp <== NOT EXECUTED 10bf75: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf77: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10bf7a: a1 b4 4b 12 00 mov 0x124bb4,%eax <== NOT EXECUTED 10bf7f: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10bf82: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10bf86: 74 54 je 10bfdc <== NOT EXECUTED /* * 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 ) 10bf88: 83 7d 0c 0f cmpl $0xf,0xc(%ebp) <== NOT EXECUTED 10bf8c: 77 46 ja 10bfd4 <== NOT EXECUTED /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10bf8e: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10bf91: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bf93: 74 4f je 10bfe4 <== NOT EXECUTED 10bf95: a1 dc 4b 12 00 mov 0x124bdc,%eax <== NOT EXECUTED 10bf9a: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bf9d: 3b 50 08 cmp 0x8(%eax),%edx <== NOT EXECUTED 10bfa0: 74 47 je 10bfe9 <== NOT EXECUTED api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10bfa2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bfa5: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10bfa8: 50 push %eax <== NOT EXECUTED 10bfa9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bfac: e8 13 1e 00 00 call 10ddc4 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10bfb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bfb4: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10bfb7: 85 d2 test %edx,%edx <== NOT EXECUTED 10bfb9: 75 45 jne 10c000 <== NOT EXECUTED case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10bfbb: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10bfc1: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10bfc4: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10bfc7: 89 54 88 20 mov %edx,0x20(%eax,%ecx,4) <== NOT EXECUTED _Thread_Enable_dispatch(); 10bfcb: e8 d0 1d 00 00 call 10dda0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10bfd0: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bfd2: c9 leave <== NOT EXECUTED 10bfd3: c3 ret <== NOT EXECUTED /* * 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 ) 10bfd4: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bfd9: c9 leave <== NOT EXECUTED 10bfda: c3 ret <== NOT EXECUTED 10bfdb: 90 nop <== NOT EXECUTED { register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10bfdc: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bfe1: c9 leave <== NOT EXECUTED 10bfe2: c3 ret <== NOT EXECUTED 10bfe3: 90 nop <== NOT EXECUTED 10bfe4: a1 dc 4b 12 00 mov 0x124bdc,%eax <== NOT EXECUTED */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || _Objects_Are_ids_equal( id, _Thread_Executing->Object.id ) ) { api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10bfe9: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10bfef: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10bff2: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10bff5: 89 54 88 20 mov %edx,0x20(%eax,%ecx,4) <== NOT EXECUTED 10bff9: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bffb: c9 leave <== NOT EXECUTED 10bffc: c3 ret <== NOT EXECUTED 10bffd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 10c000: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c005: c9 leave <== NOT EXECUTED 10c006: c3 ret <== NOT EXECUTED 0010f434 : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10f434: 55 push %ebp <== NOT EXECUTED 10f435: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f437: 56 push %esi <== NOT EXECUTED 10f438: 53 push %ebx <== NOT EXECUTED 10f439: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10f43c: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10f43f: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10f442: 85 db test %ebx,%ebx <== NOT EXECUTED 10f444: 74 0b je 10f451 <== NOT EXECUTED bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ); 10f446: 0f b6 05 f4 84 12 00 movzbl 0x1284f4,%eax <== NOT EXECUTED 10f44d: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10f44f: 77 5f ja 10f4b0 <== NOT EXECUTED !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10f451: 85 f6 test %esi,%esi <== NOT EXECUTED 10f453: 74 67 je 10f4bc <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10f455: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f458: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10f45b: 50 push %eax <== NOT EXECUTED 10f45c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f45f: e8 44 1d 00 00 call 1111a8 <_Thread_Get> <== NOT EXECUTED 10f464: 89 c2 mov %eax,%edx <== NOT EXECUTED switch ( location ) { 10f466: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f469: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10f46c: 85 c0 test %eax,%eax <== NOT EXECUTED 10f46e: 74 0c je 10f47c <== NOT EXECUTED 10f470: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f475: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f478: 5b pop %ebx <== NOT EXECUTED 10f479: 5e pop %esi <== NOT EXECUTED 10f47a: c9 leave <== NOT EXECUTED 10f47b: c3 ret <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: /* XXX need helper to "convert" from core priority */ *old_priority = the_thread->current_priority; 10f47c: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 10f47f: 89 06 mov %eax,(%esi) <== NOT EXECUTED if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10f481: 85 db test %ebx,%ebx <== NOT EXECUTED 10f483: 74 1c je 10f4a1 <== NOT EXECUTED the_thread->real_priority = new_priority; 10f485: 89 5a 18 mov %ebx,0x18(%edx) <== NOT EXECUTED if ( the_thread->resource_count == 0 || 10f488: 8b 4a 1c mov 0x1c(%edx),%ecx <== NOT EXECUTED 10f48b: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f48d: 74 05 je 10f494 <== NOT EXECUTED 10f48f: 3b 5a 14 cmp 0x14(%edx),%ebx <== NOT EXECUTED 10f492: 73 0d jae 10f4a1 <== NOT EXECUTED the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 10f494: 50 push %eax <== NOT EXECUTED 10f495: 6a 00 push $0x0 <== NOT EXECUTED 10f497: 53 push %ebx <== NOT EXECUTED 10f498: 52 push %edx <== NOT EXECUTED 10f499: e8 de 17 00 00 call 110c7c <_Thread_Change_priority> <== NOT EXECUTED 10f49e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _Thread_Enable_dispatch(); 10f4a1: e8 b2 1c 00 00 call 111158 <_Thread_Enable_dispatch> <== NOT EXECUTED 10f4a6: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f4a8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f4ab: 5b pop %ebx <== NOT EXECUTED 10f4ac: 5e pop %esi <== NOT EXECUTED 10f4ad: c9 leave <== NOT EXECUTED 10f4ae: c3 ret <== NOT EXECUTED 10f4af: 90 nop <== NOT EXECUTED 10f4b0: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED 10f4b5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f4b8: 5b pop %ebx <== NOT EXECUTED 10f4b9: 5e pop %esi <== NOT EXECUTED 10f4ba: c9 leave <== NOT EXECUTED 10f4bb: c3 ret <== NOT EXECUTED if ( new_priority != RTEMS_CURRENT_PRIORITY && !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10f4bc: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f4c1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f4c4: 5b pop %ebx <== NOT EXECUTED 10f4c5: 5e pop %esi <== NOT EXECUTED 10f4c6: c9 leave <== NOT EXECUTED 10f4c7: c3 ret <== NOT EXECUTED 0010a7e4 : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 10a7e4: 55 push %ebp <== NOT EXECUTED 10a7e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a7e7: 53 push %ebx <== NOT EXECUTED 10a7e8: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10a7eb: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 10a7ee: 85 db test %ebx,%ebx <== NOT EXECUTED 10a7f0: 74 5a je 10a84c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10a7f2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a7f5: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a7f8: 50 push %eax <== NOT EXECUTED 10a7f9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a7fc: e8 6f 1b 00 00 call 10c370 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10a801: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a804: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10a807: 85 d2 test %edx,%edx <== NOT EXECUTED 10a809: 74 0d je 10a818 <== NOT EXECUTED 10a80b: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a810: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a813: c9 leave <== NOT EXECUTED 10a814: c3 ret <== NOT EXECUTED 10a815: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _Thread_Start( 10a818: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a81b: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a81e: 6a 00 push $0x0 <== NOT EXECUTED 10a820: 53 push %ebx <== NOT EXECUTED 10a821: 6a 00 push $0x0 <== NOT EXECUTED 10a823: 50 push %eax <== NOT EXECUTED 10a824: e8 1f 26 00 00 call 10ce48 <_Thread_Start> <== NOT EXECUTED 10a829: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a82c: 84 c0 test %al,%al <== NOT EXECUTED 10a82e: 75 10 jne 10a840 <== NOT EXECUTED the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10a830: e8 17 1b 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a835: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a83a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a83d: c9 leave <== NOT EXECUTED 10a83e: c3 ret <== NOT EXECUTED 10a83f: 90 nop <== NOT EXECUTED switch ( location ) { case OBJECTS_LOCAL: if ( _Thread_Start( the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); 10a840: e8 07 1b 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED 10a845: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a847: eb c7 jmp 10a810 <== NOT EXECUTED 10a849: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 10a84c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a851: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a854: c9 leave <== NOT EXECUTED 10a855: c3 ret <== NOT EXECUTED 0010b9f4 : */ rtems_status_code rtems_task_suspend( Objects_Id id ) { 10b9f4: 55 push %ebp <== NOT EXECUTED 10b9f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b9f7: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10b9fa: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b9fd: 50 push %eax <== NOT EXECUTED 10b9fe: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ba01: e8 62 1e 00 00 call 10d868 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10ba06: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ba09: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10ba0c: 85 d2 test %edx,%edx <== NOT EXECUTED 10ba0e: 74 08 je 10ba18 <== NOT EXECUTED 10ba10: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ba15: c9 leave <== NOT EXECUTED 10ba16: c3 ret <== NOT EXECUTED 10ba17: 90 nop <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 10ba18: f6 40 10 02 testb $0x2,0x10(%eax) <== NOT EXECUTED 10ba1c: 74 0e je 10ba2c <== NOT EXECUTED _Thread_Suspend( the_thread ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10ba1e: e8 f5 1d 00 00 call 10d818 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ba23: b8 0f 00 00 00 mov $0xf,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ba28: c9 leave <== NOT EXECUTED 10ba29: c3 ret <== NOT EXECUTED 10ba2a: 66 90 xchg %ax,%ax <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { _Thread_Suspend( the_thread ); 10ba2c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ba2f: 50 push %eax <== NOT EXECUTED 10ba30: e8 1b 2a 00 00 call 10e450 <_Thread_Suspend> <== NOT EXECUTED _Thread_Enable_dispatch(); 10ba35: e8 de 1d 00 00 call 10d818 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ba3a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ba3c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ba3f: c9 leave <== NOT EXECUTED 10ba40: c3 ret <== NOT EXECUTED 00126878 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 126878: 55 push %ebp <== NOT EXECUTED 126879: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12687b: 56 push %esi <== NOT EXECUTED 12687c: 53 push %ebx <== NOT EXECUTED 12687d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 126880: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 126883: 85 db test %ebx,%ebx <== NOT EXECUTED 126885: 0f 84 a1 00 00 00 je 12692c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 12688b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12688e: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 126891: 50 push %eax <== NOT EXECUTED 126892: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126895: e8 02 af fe ff call 11179c <_Thread_Get> <== NOT EXECUTED 12689a: 89 c6 mov %eax,%esi <== NOT EXECUTED switch (location) { 12689c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12689f: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 1268a2: 85 c0 test %eax,%eax <== NOT EXECUTED 1268a4: 75 2e jne 1268d4 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 1268a6: 8b 86 04 01 00 00 mov 0x104(%esi),%eax <== NOT EXECUTED while (tvp) { 1268ac: 85 c0 test %eax,%eax <== NOT EXECUTED 1268ae: 75 0a jne 1268ba <== NOT EXECUTED 1268b0: eb 2e jmp 1268e0 <== NOT EXECUTED 1268b2: 66 90 xchg %ax,%ax <== NOT EXECUTED if (tvp->ptr == ptr) { tvp->dtor = dtor; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 1268b4: 8b 00 mov (%eax),%eax <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 1268b6: 85 c0 test %eax,%eax <== NOT EXECUTED 1268b8: 74 26 je 1268e0 <== NOT EXECUTED if (tvp->ptr == ptr) { 1268ba: 39 58 04 cmp %ebx,0x4(%eax) <== NOT EXECUTED 1268bd: 75 f5 jne 1268b4 <== NOT EXECUTED tvp->dtor = dtor; 1268bf: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 1268c2: 89 50 10 mov %edx,0x10(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 1268c5: e8 ae ae fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 1268ca: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1268cc: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1268cf: 5b pop %ebx <== NOT EXECUTED 1268d0: 5e pop %esi <== NOT EXECUTED 1268d1: c9 leave <== NOT EXECUTED 1268d2: c3 ret <== NOT EXECUTED 1268d3: 90 nop <== NOT EXECUTED if ( !ptr ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 1268d4: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1268d9: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1268dc: 5b pop %ebx <== NOT EXECUTED 1268dd: 5e pop %esi <== NOT EXECUTED 1268de: c9 leave <== NOT EXECUTED 1268df: c3 ret <== NOT EXECUTED } /* * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) 1268e0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1268e3: 6a 14 push $0x14 <== NOT EXECUTED 1268e5: e8 c2 bf fe ff call 1128ac <_Workspace_Allocate> <== NOT EXECUTED 1268ea: 89 c2 mov %eax,%edx <== NOT EXECUTED _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 1268ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1268ef: 85 c0 test %eax,%eax <== NOT EXECUTED 1268f1: 74 2d je 126920 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 1268f3: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 1268f5: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED new->ptr = ptr; 1268f8: 89 5a 04 mov %ebx,0x4(%edx) <== NOT EXECUTED new->dtor = dtor; 1268fb: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1268fe: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 126901: 8b 86 04 01 00 00 mov 0x104(%esi),%eax <== NOT EXECUTED 126907: 89 02 mov %eax,(%edx) <== NOT EXECUTED the_thread->task_variables = new; 126909: 89 96 04 01 00 00 mov %edx,0x104(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 12690f: e8 64 ae fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 126914: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126916: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126919: 5b pop %ebx <== NOT EXECUTED 12691a: 5e pop %esi <== NOT EXECUTED 12691b: c9 leave <== NOT EXECUTED 12691c: c3 ret <== NOT EXECUTED 12691d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { _Thread_Enable_dispatch(); 126920: e8 53 ae fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 126925: b8 1a 00 00 00 mov $0x1a,%eax <== NOT EXECUTED 12692a: eb ad jmp 1268d9 <== NOT EXECUTED { Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 12692c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126931: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126934: 5b pop %ebx <== NOT EXECUTED 126935: 5e pop %esi <== NOT EXECUTED 126936: c9 leave <== NOT EXECUTED 126937: c3 ret <== NOT EXECUTED 00126938 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 126938: 55 push %ebp <== NOT EXECUTED 126939: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12693b: 56 push %esi <== NOT EXECUTED 12693c: 53 push %ebx <== NOT EXECUTED 12693d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 126940: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 126943: 85 db test %ebx,%ebx <== NOT EXECUTED 126945: 74 3f je 126986 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 126947: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12694a: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 12694d: 50 push %eax <== NOT EXECUTED 12694e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 126951: e8 46 ae fe ff call 11179c <_Thread_Get> <== NOT EXECUTED 126956: 89 c6 mov %eax,%esi <== NOT EXECUTED switch (location) { 126958: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12695b: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 12695e: 85 c0 test %eax,%eax <== NOT EXECUTED 126960: 75 32 jne 126994 <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; 126962: 8b 96 04 01 00 00 mov 0x104(%esi),%edx <== NOT EXECUTED while (tvp) { 126968: 85 d2 test %edx,%edx <== NOT EXECUTED 12696a: 74 15 je 126981 <== NOT EXECUTED if (tvp->ptr == ptr) { 12696c: 39 5a 04 cmp %ebx,0x4(%edx) <== NOT EXECUTED 12696f: 75 08 jne 126979 <== NOT EXECUTED 126971: eb 4c jmp 1269bf <== NOT EXECUTED 126973: 90 nop <== NOT EXECUTED 126974: 39 5a 04 cmp %ebx,0x4(%edx) <== NOT EXECUTED 126977: 74 27 je 1269a0 <== NOT EXECUTED else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 126979: 89 d1 mov %edx,%ecx <== NOT EXECUTED } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 12697b: 8b 12 mov (%edx),%edx <== NOT EXECUTED the_thread = _Thread_Get (tid, &location); switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 12697d: 85 d2 test %edx,%edx <== NOT EXECUTED 12697f: 75 f3 jne 126974 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 126981: e8 f2 ad fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 126986: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12698b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12698e: 5b pop %ebx <== NOT EXECUTED 12698f: 5e pop %esi <== NOT EXECUTED 126990: c9 leave <== NOT EXECUTED 126991: c3 ret <== NOT EXECUTED 126992: 66 90 xchg %ax,%ax <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); switch (location) { 126994: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126999: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12699c: 5b pop %ebx <== NOT EXECUTED 12699d: 5e pop %esi <== NOT EXECUTED 12699e: c9 leave <== NOT EXECUTED 12699f: c3 ret <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 1269a0: 8b 02 mov (%edx),%eax <== NOT EXECUTED 1269a2: 89 01 mov %eax,(%ecx) <== NOT EXECUTED else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); 1269a4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1269a7: 52 push %edx <== NOT EXECUTED 1269a8: 56 push %esi <== NOT EXECUTED 1269a9: e8 a6 00 00 00 call 126a54 <_RTEMS_Tasks_Invoke_task_variable_dtor> <== NOT EXECUTED _Thread_Enable_dispatch(); 1269ae: e8 c5 ad fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 1269b3: 31 c0 xor %eax,%eax <== NOT EXECUTED 1269b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1269b8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1269bb: 5b pop %ebx <== NOT EXECUTED 1269bc: 5e pop %esi <== NOT EXECUTED 1269bd: c9 leave <== NOT EXECUTED 1269be: c3 ret <== 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; 1269bf: 8b 02 mov (%edx),%eax <== NOT EXECUTED 1269c1: 89 86 04 01 00 00 mov %eax,0x104(%esi) <== NOT EXECUTED 1269c7: eb db jmp 1269a4 <== NOT EXECUTED 001269cc : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 1269cc: 55 push %ebp <== NOT EXECUTED 1269cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1269cf: 56 push %esi <== NOT EXECUTED 1269d0: 53 push %ebx <== NOT EXECUTED 1269d1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1269d4: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 1269d7: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 1269da: 85 db test %ebx,%ebx <== NOT EXECUTED 1269dc: 74 56 je 126a34 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 1269de: 85 f6 test %esi,%esi <== NOT EXECUTED 1269e0: 74 52 je 126a34 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 1269e2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1269e5: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1269e8: 50 push %eax <== NOT EXECUTED 1269e9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1269ec: e8 ab ad fe ff call 11179c <_Thread_Get> <== NOT EXECUTED switch (location) { 1269f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1269f4: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 1269f7: 85 d2 test %edx,%edx <== NOT EXECUTED 1269f9: 75 2d jne 126a28 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 1269fb: 8b 80 04 01 00 00 mov 0x104(%eax),%eax <== NOT EXECUTED while (tvp) { 126a01: 85 c0 test %eax,%eax <== NOT EXECUTED 126a03: 75 09 jne 126a0e <== NOT EXECUTED 126a05: eb 39 jmp 126a40 <== NOT EXECUTED 126a07: 90 nop <== NOT EXECUTED */ *result = tvp->tval; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 126a08: 8b 00 mov (%eax),%eax <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 126a0a: 85 c0 test %eax,%eax <== NOT EXECUTED 126a0c: 74 32 je 126a40 <== NOT EXECUTED if (tvp->ptr == ptr) { 126a0e: 39 58 04 cmp %ebx,0x4(%eax) <== NOT EXECUTED 126a11: 75 f5 jne 126a08 <== NOT EXECUTED /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 126a13: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 126a16: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 126a18: e8 5b ad fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 126a1d: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126a1f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126a22: 5b pop %ebx <== NOT EXECUTED 126a23: 5e pop %esi <== NOT EXECUTED 126a24: c9 leave <== NOT EXECUTED 126a25: c3 ret <== NOT EXECUTED 126a26: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !result ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 126a28: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126a2d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126a30: 5b pop %ebx <== NOT EXECUTED 126a31: 5e pop %esi <== NOT EXECUTED 126a32: c9 leave <== NOT EXECUTED 126a33: c3 ret <== NOT EXECUTED return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; 126a34: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126a39: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126a3c: 5b pop %ebx <== NOT EXECUTED 126a3d: 5e pop %esi <== NOT EXECUTED 126a3e: c9 leave <== NOT EXECUTED 126a3f: c3 ret <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 126a40: e8 33 ad fe ff call 111778 <_Thread_Enable_dispatch> <== NOT EXECUTED 126a45: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126a4a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126a4d: 5b pop %ebx <== NOT EXECUTED 126a4e: 5e pop %esi <== NOT EXECUTED 126a4f: c9 leave <== NOT EXECUTED 126a50: c3 ret <== NOT EXECUTED 0010a858 : */ rtems_status_code rtems_task_wake_after( rtems_interval ticks ) { 10a858: 55 push %ebp <== NOT EXECUTED 10a859: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a85b: 53 push %ebx <== NOT EXECUTED 10a85c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a85f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a862: a1 b8 f7 11 00 mov 0x11f7b8,%eax <== NOT EXECUTED 10a867: 40 inc %eax <== NOT EXECUTED 10a868: a3 b8 f7 11 00 mov %eax,0x11f7b8 <== NOT EXECUTED _Thread_Disable_dispatch(); if ( ticks == 0 ) { 10a86d: 85 db test %ebx,%ebx <== NOT EXECUTED 10a86f: 74 53 je 10a8c4 <== NOT EXECUTED _Thread_Yield_processor(); } else { _Thread_Set_state( _Thread_Executing, STATES_DELAYING ); 10a871: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a874: 6a 08 push $0x8 <== NOT EXECUTED 10a876: ff 35 7c f8 11 00 pushl 0x11f87c <== NOT EXECUTED 10a87c: e8 7f 23 00 00 call 10cc00 <_Thread_Set_state> <== NOT EXECUTED _Watchdog_Initialize( 10a881: a1 7c f8 11 00 mov 0x11f87c,%eax <== NOT EXECUTED 10a886: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10a889: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10a890: c7 40 64 b4 c1 10 00 movl $0x10c1b4,0x64(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10a897: 89 50 68 mov %edx,0x68(%eax) <== NOT EXECUTED * the heap 10a89a: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax) <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 10a8a1: 89 58 54 mov %ebx,0x54(%eax) <== NOT EXECUTED void *starting_address, size_t *size 10a8a4: 5a pop %edx <== NOT EXECUTED 10a8a5: 59 pop %ecx <== NOT EXECUTED 10a8a6: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 10a8a9: 50 push %eax <== NOT EXECUTED 10a8aa: 68 9c f8 11 00 push $0x11f89c <== NOT EXECUTED 10a8af: e8 a8 29 00 00 call 10d25c <_Watchdog_Insert> <== NOT EXECUTED 10a8b4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); } _Thread_Enable_dispatch(); 10a8b7: e8 90 1a 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10a8bc: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a8be: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a8c1: c9 leave <== NOT EXECUTED 10a8c2: c3 ret <== NOT EXECUTED 10a8c3: 90 nop <== NOT EXECUTED rtems_interval ticks ) { _Thread_Disable_dispatch(); if ( ticks == 0 ) { _Thread_Yield_processor(); 10a8c4: e8 4b 26 00 00 call 10cf14 <_Thread_Yield_processor> <== NOT EXECUTED _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); } _Thread_Enable_dispatch(); 10a8c9: e8 7e 1a 00 00 call 10c34c <_Thread_Enable_dispatch> <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10a8ce: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a8d0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a8d3: c9 leave <== NOT EXECUTED 10a8d4: c3 ret <== NOT EXECUTED 0010b4e0 : */ rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) { 10b4e0: 55 push %ebp <== NOT EXECUTED 10b4e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4e3: 53 push %ebx <== NOT EXECUTED 10b4e4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b4e7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED Watchdog_Interval seconds; if ( !_TOD_Is_set ) 10b4ea: 80 3d ec 2f 12 00 00 cmpb $0x0,0x122fec <== NOT EXECUTED 10b4f1: 0f 84 a1 00 00 00 je 10b598 <== NOT EXECUTED return RTEMS_NOT_DEFINED; if ( !time_buffer ) 10b4f7: 85 db test %ebx,%ebx <== NOT EXECUTED 10b4f9: 0f 84 a5 00 00 00 je 10b5a4 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; time_buffer->ticks = 0; 10b4ff: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED if ( !_TOD_Validate( time_buffer ) ) 10b506: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b509: 53 push %ebx <== NOT EXECUTED 10b50a: e8 c1 f3 ff ff call 10a8d0 <_TOD_Validate> <== NOT EXECUTED 10b50f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b512: 84 c0 test %al,%al <== NOT EXECUTED 10b514: 75 0a jne 10b520 <== NOT EXECUTED _Watchdog_Insert_seconds( &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 10b516: b8 14 00 00 00 mov $0x14,%eax <== NOT EXECUTED } 10b51b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b51e: c9 leave <== NOT EXECUTED 10b51f: c3 ret <== NOT EXECUTED time_buffer->ticks = 0; if ( !_TOD_Validate( time_buffer ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); 10b520: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b523: 53 push %ebx <== NOT EXECUTED 10b524: e8 17 f3 ff ff call 10a840 <_TOD_To_seconds> <== NOT EXECUTED 10b529: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( seconds <= _TOD_Seconds_since_epoch ) 10b52b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b52e: 3b 05 6c 30 12 00 cmp 0x12306c,%eax <== NOT EXECUTED 10b534: 76 e0 jbe 10b516 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10b536: a1 d8 2f 12 00 mov 0x122fd8,%eax <== NOT EXECUTED 10b53b: 40 inc %eax <== NOT EXECUTED 10b53c: a3 d8 2f 12 00 mov %eax,0x122fd8 <== NOT EXECUTED return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); 10b541: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b544: 6a 10 push $0x10 <== NOT EXECUTED 10b546: ff 35 9c 30 12 00 pushl 0x12309c <== NOT EXECUTED 10b54c: e8 23 24 00 00 call 10d974 <_Thread_Set_state> <== NOT EXECUTED _Watchdog_Initialize( 10b551: a1 9c 30 12 00 mov 0x12309c,%eax <== NOT EXECUTED 10b556: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10b559: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10b560: c7 40 64 28 cf 10 00 movl $0x10cf28,0x64(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10b567: 89 50 68 mov %edx,0x68(%eax) <== NOT EXECUTED * the heap 10b56a: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax) <== NOT EXECUTED * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, 10b571: 2b 1d 6c 30 12 00 sub 0x12306c,%ebx <== NOT EXECUTED 10b577: 89 58 54 mov %ebx,0x54(%eax) <== NOT EXECUTED size_t size ); 10b57a: 5a pop %edx <== NOT EXECUTED 10b57b: 59 pop %ecx <== NOT EXECUTED 10b57c: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 10b57f: 50 push %eax <== NOT EXECUTED 10b580: 68 b0 30 12 00 push $0x1230b0 <== NOT EXECUTED 10b585: e8 c2 2a 00 00 call 10e04c <_Watchdog_Insert> <== NOT EXECUTED ); _Watchdog_Insert_seconds( &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); 10b58a: e8 31 1b 00 00 call 10d0c0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b58f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b591: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b594: eb 85 jmp 10b51b <== NOT EXECUTED 10b596: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_time_of_day *time_buffer ) { Watchdog_Interval seconds; if ( !_TOD_Is_set ) 10b598: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b59d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b5a0: c9 leave <== NOT EXECUTED 10b5a1: c3 ret <== NOT EXECUTED 10b5a2: 66 90 xchg %ax,%ax <== NOT EXECUTED Watchdog_Interval seconds; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !time_buffer ) 10b5a4: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b5a9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b5ac: c9 leave <== NOT EXECUTED 10b5ad: c3 ret <== NOT EXECUTED 00107f94 : rtems_status_code rtems_termios_bufsize ( int cbufsize, int raw_input, int raw_output ) { 107f94: 55 push %ebp <== NOT EXECUTED 107f95: 89 e5 mov %esp,%ebp <== NOT EXECUTED rtems_termios_cbufsize = cbufsize; 107f97: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 107f9a: a3 44 d5 11 00 mov %eax,0x11d544 <== NOT EXECUTED rtems_termios_raw_input_size = raw_input; 107f9f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 107fa2: a3 48 d5 11 00 mov %eax,0x11d548 <== NOT EXECUTED rtems_termios_raw_output_size = raw_output; 107fa7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 107faa: a3 4c d5 11 00 mov %eax,0x11d54c <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 107faf: 31 c0 xor %eax,%eax <== NOT EXECUTED 107fb1: c9 leave <== NOT EXECUTED 107fb2: c3 ret <== NOT EXECUTED 001093d4 : } } rtems_status_code rtems_termios_close (void *arg) { 1093d4: 55 push %ebp <== NOT EXECUTED 1093d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1093d7: 56 push %esi <== NOT EXECUTED 1093d8: 53 push %ebx <== NOT EXECUTED 1093d9: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 1093dc: 8b 06 mov (%esi),%eax <== NOT EXECUTED 1093de: 8b 58 28 mov 0x28(%eax),%ebx <== NOT EXECUTED rtems_status_code sc; sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 1093e1: 51 push %ecx <== NOT EXECUTED 1093e2: 6a 00 push $0x0 <== NOT EXECUTED 1093e4: 6a 00 push $0x0 <== NOT EXECUTED 1093e6: ff 35 ec f6 11 00 pushl 0x11f6ec <== NOT EXECUTED 1093ec: e8 bb 0f 00 00 call 10a3ac <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 1093f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1093f4: 85 c0 test %eax,%eax <== NOT EXECUTED 1093f6: 0f 85 2c 01 00 00 jne 109528 <== NOT EXECUTED rtems_fatal_error_occurred (sc); if (--tty->refcount == 0) { 1093fc: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 1093ff: 48 dec %eax <== NOT EXECUTED 109400: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED 109403: 85 c0 test %eax,%eax <== NOT EXECUTED 109405: 0f 85 bf 00 00 00 jne 1094ca <== NOT EXECUTED if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 10940b: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 109411: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 109414: 8b 80 24 f4 11 00 mov 0x11f424(%eax),%eax <== NOT EXECUTED 10941a: 85 c0 test %eax,%eax <== NOT EXECUTED 10941c: 0f 84 12 01 00 00 je 109534 <== NOT EXECUTED /* * call discipline-specific close */ sc = rtems_termios_linesw[tty->t_line].l_close(tty); 109422: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109425: 53 push %ebx <== NOT EXECUTED 109426: ff d0 call *%eax <== NOT EXECUTED 109428: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * default: just flush output buffer */ drainOutput (tty); } if (tty->device.outputUsesInterrupts 10942b: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) <== NOT EXECUTED 109432: 0f 84 bc 00 00 00 je 1094f4 <== NOT EXECUTED tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } if (tty->device.lastClose) 109438: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax <== NOT EXECUTED 10943e: 85 c0 test %eax,%eax <== NOT EXECUTED 109440: 74 0d je 10944f <== NOT EXECUTED (*tty->device.lastClose)(tty->major, tty->minor, arg); 109442: 52 push %edx <== NOT EXECUTED 109443: 56 push %esi <== NOT EXECUTED 109444: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109447: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10944a: ff d0 call *%eax <== NOT EXECUTED 10944c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (tty->forw == NULL) { 10944f: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 109451: 85 d2 test %edx,%edx <== NOT EXECUTED 109453: 0f 84 e7 00 00 00 je 109540 <== NOT EXECUTED if ( rtems_termios_ttyTail != NULL ) { rtems_termios_ttyTail->forw = NULL; } } else { tty->forw->back = tty->back; 109459: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10945c: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED } if (tty->back == NULL) { 10945f: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 109462: 85 c0 test %eax,%eax <== NOT EXECUTED 109464: 0f 84 f2 00 00 00 je 10955c <== NOT EXECUTED if ( rtems_termios_ttyHead != NULL ) { rtems_termios_ttyHead->back = NULL; } } else { tty->back->forw = tty->forw; 10946a: 89 10 mov %edx,(%eax) <== NOT EXECUTED } rtems_semaphore_delete (tty->isem); 10946c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10946f: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 109472: e8 91 0e 00 00 call 10a308 <== NOT EXECUTED rtems_semaphore_delete (tty->osem); 109477: 58 pop %eax <== NOT EXECUTED 109478: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10947b: e8 88 0e 00 00 call 10a308 <== NOT EXECUTED rtems_semaphore_delete (tty->rawOutBuf.Semaphore); 109480: 58 pop %eax <== NOT EXECUTED 109481: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED 109487: e8 7c 0e 00 00 call 10a308 <== NOT EXECUTED if ((tty->device.pollRead == NULL) || 10948c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10948f: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax <== NOT EXECUTED 109495: 85 c0 test %eax,%eax <== NOT EXECUTED 109497: 74 4b je 1094e4 <== NOT EXECUTED 109499: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) <== NOT EXECUTED 1094a0: 74 42 je 1094e4 <== NOT EXECUTED (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore); free (tty->rawInBuf.theBuf); 1094a2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1094a5: ff 73 58 pushl 0x58(%ebx) <== NOT EXECUTED 1094a8: e8 f3 db ff ff call 1070a0 <== NOT EXECUTED free (tty->rawOutBuf.theBuf); 1094ad: 58 pop %eax <== NOT EXECUTED 1094ae: ff 73 7c pushl 0x7c(%ebx) <== NOT EXECUTED 1094b1: e8 ea db ff ff call 1070a0 <== NOT EXECUTED free (tty->cbuf); 1094b6: 5e pop %esi <== NOT EXECUTED 1094b7: ff 73 1c pushl 0x1c(%ebx) <== NOT EXECUTED 1094ba: e8 e1 db ff ff call 1070a0 <== NOT EXECUTED free (tty); 1094bf: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1094c2: e8 d9 db ff ff call 1070a0 <== NOT EXECUTED 1094c7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } rtems_semaphore_release (rtems_termios_ttyMutex); 1094ca: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1094cd: ff 35 ec f6 11 00 pushl 0x11f6ec <== NOT EXECUTED 1094d3: e8 cc 0f 00 00 call 10a4a4 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 1094d8: 31 c0 xor %eax,%eax <== NOT EXECUTED 1094da: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1094dd: 5b pop %ebx <== NOT EXECUTED 1094de: 5e pop %esi <== NOT EXECUTED 1094df: c9 leave <== NOT EXECUTED 1094e0: c3 ret <== NOT EXECUTED 1094e1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 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); 1094e4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1094e7: ff 73 68 pushl 0x68(%ebx) <== NOT EXECUTED 1094ea: e8 19 0e 00 00 call 10a308 <== NOT EXECUTED 1094ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1094f2: eb ae jmp 1094a2 <== NOT EXECUTED if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { /* * send "terminate" to I/O tasks */ sc = rtems_event_send( 1094f4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1094f7: 6a 01 push $0x1 <== NOT EXECUTED 1094f9: ff b3 c4 00 00 00 pushl 0xc4(%ebx) <== NOT EXECUTED 1094ff: e8 84 09 00 00 call 109e88 <== NOT EXECUTED tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) 109504: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109507: 85 c0 test %eax,%eax <== NOT EXECUTED 109509: 75 1d jne 109528 <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_event_send( 10950b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10950e: 6a 01 push $0x1 <== NOT EXECUTED 109510: ff b3 c8 00 00 00 pushl 0xc8(%ebx) <== NOT EXECUTED 109516: e8 6d 09 00 00 call 109e88 <== NOT EXECUTED tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) 10951b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10951e: 85 c0 test %eax,%eax <== NOT EXECUTED 109520: 0f 84 12 ff ff ff je 109438 <== NOT EXECUTED 109526: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_fatal_error_occurred (sc); 109528: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10952b: 50 push %eax <== NOT EXECUTED 10952c: e8 17 15 00 00 call 10aa48 <== NOT EXECUTED 109531: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } else { /* * default: just flush output buffer */ drainOutput (tty); 109534: 89 d8 mov %ebx,%eax <== NOT EXECUTED 109536: e8 d5 f6 ff ff call 108c10 <== NOT EXECUTED 10953b: e9 eb fe ff ff jmp 10942b <== 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; 109540: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 109543: a3 f0 f6 11 00 mov %eax,0x11f6f0 <== NOT EXECUTED if ( rtems_termios_ttyTail != NULL ) { 109548: 85 c0 test %eax,%eax <== NOT EXECUTED 10954a: 74 2c je 109578 <== NOT EXECUTED rtems_termios_ttyTail->forw = NULL; 10954c: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 109552: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 109554: e9 06 ff ff ff jmp 10945f <== NOT EXECUTED 109559: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } else { tty->forw->back = tty->back; } if (tty->back == NULL) { rtems_termios_ttyHead = tty->forw; 10955c: 89 15 f4 f6 11 00 mov %edx,0x11f6f4 <== NOT EXECUTED if ( rtems_termios_ttyHead != NULL ) { 109562: 85 d2 test %edx,%edx <== NOT EXECUTED 109564: 0f 84 02 ff ff ff je 10946c <== NOT EXECUTED rtems_termios_ttyHead->back = NULL; 10956a: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 109571: e9 f6 fe ff ff jmp 10946c <== NOT EXECUTED 109576: 66 90 xchg %ax,%ax <== NOT EXECUTED } else { tty->forw->back = tty->back; } if (tty->back == NULL) { rtems_termios_ttyHead = tty->forw; 109578: c7 05 f4 f6 11 00 00 movl $0x0,0x11f6f4 <== NOT EXECUTED 10957f: 00 00 00 <== NOT EXECUTED 109582: e9 e5 fe ff ff jmp 10946c <== NOT EXECUTED 001081f4 : * for each transmitted character. * It returns number of characters left to transmit */ int rtems_termios_dequeue_characters (void *ttyp, int len) { 1081f4: 55 push %ebp <== NOT EXECUTED 1081f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1081f7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1081fa: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len; 1081fd: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 108200: 01 82 90 00 00 00 add %eax,0x90(%edx) <== NOT EXECUTED if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 108206: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx) <== NOT EXECUTED 10820d: 74 2d je 10823c <== 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 ) { 10820f: 83 ba cc 00 00 00 05 cmpl $0x5,0xcc(%edx) <== NOT EXECUTED 108216: 75 18 jne 108230 <== NOT EXECUTED /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 108218: a1 d4 f4 11 00 mov 0x11f4d4,%eax <== NOT EXECUTED 10821d: 85 c0 test %eax,%eax <== NOT EXECUTED 10821f: 74 09 je 10822a <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_start(tty); 108221: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108224: 52 push %edx <== NOT EXECUTED 108225: ff d0 call *%eax <== NOT EXECUTED 108227: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; /* nothing to output in IRQ... */ } else { return rtems_termios_refill_transmitter(tty); } } 10822a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10822c: c9 leave <== NOT EXECUTED 10822d: c3 ret <== NOT EXECUTED 10822e: 66 90 xchg %ax,%ax <== 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); 108230: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } } 108233: c9 leave <== 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); 108234: e9 97 fd ff ff jmp 107fd0 <== NOT EXECUTED 108239: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { /* * send wake up to transmitter task */ sc = rtems_event_send(tty->txTaskId, 10823c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10823f: 6a 02 push $0x2 <== NOT EXECUTED 108241: ff b2 c8 00 00 00 pushl 0xc8(%edx) <== NOT EXECUTED 108247: e8 3c 1c 00 00 call 109e88 <== NOT EXECUTED TERMIOS_TX_START_EVENT); if (sc != RTEMS_SUCCESSFUL) 10824c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10824f: 85 c0 test %eax,%eax <== NOT EXECUTED 108251: 74 d7 je 10822a <== NOT EXECUTED rtems_fatal_error_occurred (sc); 108253: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108256: 50 push %eax <== NOT EXECUTED 108257: e8 ec 27 00 00 call 10aa48 <== NOT EXECUTED 0010825c : * 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) { 10825c: 55 push %ebp <== NOT EXECUTED 10825d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10825f: 57 push %edi <== NOT EXECUTED 108260: 56 push %esi <== NOT EXECUTED 108261: 53 push %ebx <== NOT EXECUTED 108262: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 108265: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 108268: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED char c; int dropped = 0; bool flow_rcv = false; /* true, if flow control char received */ rtems_interrupt_level level; if (rtems_termios_linesw[tty->t_line].l_rint != NULL) { 10826b: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED 108271: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 108274: 8b 90 30 f4 11 00 mov 0x11f430(%eax),%edx <== NOT EXECUTED 10827a: 85 d2 test %edx,%edx <== NOT EXECUTED 10827c: 0f 84 86 00 00 00 je 108308 <== NOT EXECUTED while (len--) { 108282: 85 ff test %edi,%edi <== NOT EXECUTED 108284: 74 2b je 1082b1 <== NOT EXECUTED 108286: 31 db xor %ebx,%ebx <== NOT EXECUTED 108288: eb 11 jmp 10829b <== NOT EXECUTED 10828a: 66 90 xchg %ax,%ax <== NOT EXECUTED 10828c: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED 108292: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 108295: 8b 90 30 f4 11 00 mov 0x11f430(%eax),%edx <== NOT EXECUTED c = *buf++; rtems_termios_linesw[tty->t_line].l_rint(c,tty); 10829b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10829e: 56 push %esi <== NOT EXECUTED 10829f: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1082a2: 0f be 04 19 movsbl (%ecx,%ebx,1),%eax <== NOT EXECUTED 1082a6: 50 push %eax <== NOT EXECUTED 1082a7: ff d2 call *%edx <== NOT EXECUTED 1082a9: 43 inc %ebx <== NOT EXECUTED int dropped = 0; bool flow_rcv = false; /* true, if flow control char received */ rtems_interrupt_level level; if (rtems_termios_linesw[tty->t_line].l_rint != NULL) { while (len--) { 1082aa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1082ad: 39 fb cmp %edi,%ebx <== NOT EXECUTED 1082af: 75 db jne 10828c <== NOT EXECUTED } /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 1082b1: 8b 9e e4 00 00 00 mov 0xe4(%esi),%ebx <== NOT EXECUTED 1082b7: 85 db test %ebx,%ebx <== NOT EXECUTED 1082b9: 75 39 jne 1082f4 <== NOT EXECUTED 1082bb: 8b 96 dc 00 00 00 mov 0xdc(%esi),%edx <== NOT EXECUTED 1082c1: 85 d2 test %edx,%edx <== NOT EXECUTED 1082c3: 74 2f je 1082f4 <== NOT EXECUTED (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 1082c5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1082c8: ff b6 e0 00 00 00 pushl 0xe0(%esi) <== NOT EXECUTED 1082ce: 8d 46 30 lea 0x30(%esi),%eax <== NOT EXECUTED 1082d1: 50 push %eax <== NOT EXECUTED 1082d2: ff d2 call *%edx <== NOT EXECUTED tty->tty_rcvwakeup = 1; 1082d4: c7 86 e4 00 00 00 01 movl $0x1,0xe4(%esi) <== NOT EXECUTED 1082db: 00 00 00 <== NOT EXECUTED 1082de: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) <== NOT EXECUTED 1082e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; } 1082e8: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 1082eb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1082ee: 5b pop %ebx <== NOT EXECUTED 1082ef: 5e pop %esi <== NOT EXECUTED 1082f0: 5f pop %edi <== NOT EXECUTED 1082f1: c9 leave <== NOT EXECUTED 1082f2: c3 ret <== NOT EXECUTED 1082f3: 90 nop <== NOT EXECUTED } } } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; 1082f4: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) <== NOT EXECUTED } 1082fb: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 1082fe: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108301: 5b pop %ebx <== NOT EXECUTED 108302: 5e pop %esi <== NOT EXECUTED 108303: 5f pop %edi <== NOT EXECUTED 108304: c9 leave <== NOT EXECUTED 108305: c3 ret <== NOT EXECUTED 108306: 66 90 xchg %ax,%ax <== NOT EXECUTED if ((tty->flow_ctrl & FL_OSTOP) || (tty->rawOutBufState == rob_idle)) { /* if tx is stopped due to XOFF or out of data */ /* call write function here */ tty->flow_ctrl |= FL_ISNTXOF; (*tty->device.write)(tty->minor, 108308: 8d 46 4a lea 0x4a(%esi),%eax <== NOT EXECUTED 10830b: 89 45 e0 mov %eax,-0x20(%ebp) <== 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); 10830e: 8d 56 30 lea 0x30(%esi),%edx <== NOT EXECUTED 108311: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 108314: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) <== NOT EXECUTED 10831b: c6 45 ea 00 movb $0x0,-0x16(%ebp) <== NOT EXECUTED 10831f: e9 c3 00 00 00 jmp 1083e7 <== NOT EXECUTED /* reenable interrupts */ rtems_interrupt_enable(level); } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; 108324: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED 108327: 8b 4e 64 mov 0x64(%esi),%ecx <== NOT EXECUTED 10832a: 40 inc %eax <== NOT EXECUTED 10832b: 31 d2 xor %edx,%edx <== NOT EXECUTED 10832d: f7 f1 div %ecx <== NOT EXECUTED 10832f: 89 d3 mov %edx,%ebx <== NOT EXECUTED /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); 108331: 9c pushf <== NOT EXECUTED 108332: fa cli <== NOT EXECUTED 108333: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 108336: 8b 4e 5c mov 0x5c(%esi),%ecx <== NOT EXECUTED 108339: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED 10833c: 8b 56 64 mov 0x64(%esi),%edx <== NOT EXECUTED 10833f: 29 c8 sub %ecx,%eax <== NOT EXECUTED 108341: 01 d8 add %ebx,%eax <== NOT EXECUTED 108343: 89 d1 mov %edx,%ecx <== NOT EXECUTED 108345: 31 d2 xor %edx,%edx <== NOT EXECUTED 108347: f7 f1 div %ecx <== NOT EXECUTED 108349: 3b 96 c0 00 00 00 cmp 0xc0(%esi),%edx <== NOT EXECUTED 10834f: 76 47 jbe 108398 <== NOT EXECUTED 108351: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108357: a8 01 test $0x1,%al <== NOT EXECUTED 108359: 75 3d jne 108398 <== NOT EXECUTED % tty->rawInBuf.Size) > tty->highwater) && !(tty->flow_ctrl & FL_IREQXOF)) { /* incoming data stream should be stopped */ tty->flow_ctrl |= FL_IREQXOF; 10835b: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108361: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 108364: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) 10836a: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108370: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED 108375: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED 10837a: 0f 84 5e 01 00 00 je 1084de <== NOT EXECUTED (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) 108380: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108386: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED 10838b: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED 108390: 0f 84 86 01 00 00 je 10851c <== NOT EXECUTED 108396: 66 90 xchg %ax,%ax <== NOT EXECUTED tty->device.stopRemoteTx(tty->minor); } } } /* reenable interrupts */ rtems_interrupt_enable(level); 108398: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10839b: 9d popf <== NOT EXECUTED if (newTail == tty->rawInBuf.Head) { 10839c: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED 10839f: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 1083a1: 0f 84 91 00 00 00 je 108438 <== NOT EXECUTED dropped++; } else { tty->rawInBuf.theBuf[newTail] = c; 1083a7: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED 1083aa: 8a 55 eb mov -0x15(%ebp),%dl <== NOT EXECUTED 1083ad: 88 14 18 mov %dl,(%eax,%ebx,1) <== NOT EXECUTED tty->rawInBuf.Tail = newTail; 1083b0: 89 5e 60 mov %ebx,0x60(%esi) <== NOT EXECUTED /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 1083b3: 8b 9e e4 00 00 00 mov 0xe4(%esi),%ebx <== NOT EXECUTED 1083b9: 85 db test %ebx,%ebx <== NOT EXECUTED 1083bb: 75 27 jne 1083e4 <== NOT EXECUTED 1083bd: 8b 86 dc 00 00 00 mov 0xdc(%esi),%eax <== NOT EXECUTED 1083c3: 85 c0 test %eax,%eax <== NOT EXECUTED 1083c5: 74 1d je 1083e4 <== NOT EXECUTED (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 1083c7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1083ca: ff b6 e0 00 00 00 pushl 0xe0(%esi) <== NOT EXECUTED 1083d0: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 1083d3: ff d0 call *%eax <== NOT EXECUTED tty->tty_rcvwakeup = 1; 1083d5: c7 86 e4 00 00 00 01 movl $0x1,0xe4(%esi) <== NOT EXECUTED 1083dc: 00 00 00 <== NOT EXECUTED 1083df: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1083e2: 66 90 xchg %ax,%ax <== NOT EXECUTED } return 0; } while (len--) { c = *buf++; 1083e4: ff 45 0c incl 0xc(%ebp) <== NOT EXECUTED tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 1083e7: 4f dec %edi <== NOT EXECUTED 1083e8: 83 ff ff cmp $0xffffffff,%edi <== NOT EXECUTED 1083eb: 0f 84 9f 00 00 00 je 108490 <== NOT EXECUTED c = *buf++; 1083f1: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1083f4: 8a 00 mov (%eax),%al <== NOT EXECUTED 1083f6: 88 45 eb mov %al,-0x15(%ebp) <== NOT EXECUTED /* FIXME: implement IXANY: any character restarts output */ /* if incoming XON/XOFF controls outgoing stream: */ if (tty->flow_ctrl & FL_MDXON) { 1083f9: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 1083ff: f6 c4 02 test $0x2,%ah <== NOT EXECUTED 108402: 74 14 je 108418 <== NOT EXECUTED /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { 108404: 0f be 55 eb movsbl -0x15(%ebp),%edx <== NOT EXECUTED 108408: 0f b6 46 4a movzbl 0x4a(%esi),%eax <== NOT EXECUTED 10840c: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10840e: 74 50 je 108460 <== NOT EXECUTED /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; } flow_rcv = true; } else if (c == tty->termios.c_cc[VSTART]) { 108410: 0f b6 46 49 movzbl 0x49(%esi),%eax <== NOT EXECUTED 108414: 39 c2 cmp %eax,%edx <== NOT EXECUTED 108416: 74 64 je 10847c <== NOT EXECUTED /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; flow_rcv = true; } } if (flow_rcv) { 108418: 80 7d ea 00 cmpb $0x0,-0x16(%ebp) <== NOT EXECUTED 10841c: 0f 84 02 ff ff ff je 108324 <== NOT EXECUTED /* restart output according to FL_ORCVXOF flag */ if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) { 108422: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108428: 83 e0 30 and $0x30,%eax <== NOT EXECUTED 10842b: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED 10842e: 74 10 je 108440 <== 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); 108430: c6 45 ea 01 movb $0x1,-0x16(%ebp) <== NOT EXECUTED 108434: eb ae jmp 1083e4 <== NOT EXECUTED 108436: 66 90 xchg %ax,%ax <== NOT EXECUTED } /* reenable interrupts */ rtems_interrupt_enable(level); if (newTail == tty->rawInBuf.Head) { dropped++; 108438: ff 45 e4 incl -0x1c(%ebp) <== NOT EXECUTED 10843b: eb a7 jmp 1083e4 <== NOT EXECUTED 10843d: 8d 76 00 lea 0x0(%esi),%esi <== 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); 108440: 9c pushf <== NOT EXECUTED 108441: fa cli <== NOT EXECUTED 108442: 5b pop %ebx <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 108443: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108449: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 10844c: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { 108452: 8b 8e 94 00 00 00 mov 0x94(%esi),%ecx <== NOT EXECUTED 108458: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10845a: 75 53 jne 1084af <== 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); 10845c: 53 push %ebx <== NOT EXECUTED 10845d: 9d popf <== NOT EXECUTED 10845e: eb d0 jmp 108430 <== 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]) { 108460: 0f b6 46 49 movzbl 0x49(%esi),%eax <== NOT EXECUTED 108464: 39 c2 cmp %eax,%edx <== NOT EXECUTED 108466: 74 62 je 1084ca <== NOT EXECUTED tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; } else { /* VSTOP received (other code than VSTART) */ /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; 108468: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 10846e: 83 c8 10 or $0x10,%eax <== NOT EXECUTED 108471: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED 108477: eb a9 jmp 108422 <== NOT EXECUTED 108479: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED flow_rcv = true; } else if (c == tty->termios.c_cc[VSTART]) { /* VSTART received */ /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; 10847c: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108482: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED 108485: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED 10848b: eb 95 jmp 108422 <== NOT EXECUTED 10848d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED tty->tty_rcvwakeup = 1; } } } } tty->rawInBufDropped += dropped; 108490: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 108493: 01 4e 78 add %ecx,0x78(%esi) <== NOT EXECUTED rtems_semaphore_release (tty->rawInBuf.Semaphore); 108496: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108499: ff 76 68 pushl 0x68(%esi) <== NOT EXECUTED 10849c: e8 03 20 00 00 call 10a4a4 <== NOT EXECUTED 1084a1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return dropped; } 1084a4: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 1084a7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1084aa: 5b pop %ebx <== NOT EXECUTED 1084ab: 5e pop %esi <== NOT EXECUTED 1084ac: 5f pop %edi <== NOT EXECUTED 1084ad: c9 leave <== NOT EXECUTED 1084ae: c3 ret <== 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, 1084af: 8b 86 84 00 00 00 mov 0x84(%esi),%eax <== NOT EXECUTED 1084b5: 52 push %edx <== NOT EXECUTED 1084b6: 6a 01 push $0x1 <== NOT EXECUTED 1084b8: 03 46 7c add 0x7c(%esi),%eax <== NOT EXECUTED 1084bb: 50 push %eax <== NOT EXECUTED 1084bc: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 1084bf: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED 1084c5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1084c8: eb 92 jmp 10845c <== 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; 1084ca: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 1084d0: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED 1084d3: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED 1084d9: e9 44 ff ff ff jmp 108422 <== 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) || 1084de: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 1084e4: a8 20 test $0x20,%al <== NOT EXECUTED 1084e6: 75 0e jne 1084f6 <== NOT EXECUTED 1084e8: 8b 86 94 00 00 00 mov 0x94(%esi),%eax <== NOT EXECUTED 1084ee: 85 c0 test %eax,%eax <== NOT EXECUTED 1084f0: 0f 85 a2 fe ff ff jne 108398 <== 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; 1084f6: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 1084fc: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 1084ff: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED (*tty->device.write)(tty->minor, 108505: 50 push %eax <== NOT EXECUTED 108506: 6a 01 push $0x1 <== NOT EXECUTED 108508: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10850b: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 10850e: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED 108514: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108517: e9 7c fe ff ff jmp 108398 <== NOT EXECUTED 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS ) ) { tty->flow_ctrl |= FL_IRTSOFF; 10851c: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108522: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 108525: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED /* deactivate RTS line */ if (tty->device.stopRemoteTx != NULL) { 10852b: 8b 86 ac 00 00 00 mov 0xac(%esi),%eax <== NOT EXECUTED 108531: 85 c0 test %eax,%eax <== NOT EXECUTED 108533: 0f 84 5f fe ff ff je 108398 <== NOT EXECUTED tty->device.stopRemoteTx(tty->minor); 108539: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10853c: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 10853f: ff d0 call *%eax <== NOT EXECUTED 108541: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108544: e9 4f fe ff ff jmp 108398 <== NOT EXECUTED 00107f58 : struct rtems_termios_tty *rtems_termios_ttyTail; rtems_id rtems_termios_ttyMutex; void rtems_termios_initialize (void) { 107f58: 55 push %ebp <== NOT EXECUTED 107f59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107f5b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_status_code sc; /* * Create the mutex semaphore for the tty list */ if (!rtems_termios_ttyMutex) { 107f5e: a1 ec f6 11 00 mov 0x11f6ec,%eax <== NOT EXECUTED 107f63: 85 c0 test %eax,%eax <== NOT EXECUTED 107f65: 74 05 je 107f6c <== NOT EXECUTED RTEMS_NO_PRIORITY, &rtems_termios_ttyMutex); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } } 107f67: c9 leave <== NOT EXECUTED 107f68: c3 ret <== NOT EXECUTED 107f69: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Create the mutex semaphore for the tty list */ if (!rtems_termios_ttyMutex) { sc = rtems_semaphore_create ( 107f6c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107f6f: 68 ec f6 11 00 push $0x11f6ec <== NOT EXECUTED 107f74: 6a 00 push $0x0 <== NOT EXECUTED 107f76: 6a 54 push $0x54 <== NOT EXECUTED 107f78: 6a 01 push $0x1 <== NOT EXECUTED 107f7a: 68 69 6d 52 54 push $0x54526d69 <== NOT EXECUTED 107f7f: e8 a8 21 00 00 call 10a12c <== NOT EXECUTED 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) 107f84: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 107f87: 85 c0 test %eax,%eax <== NOT EXECUTED 107f89: 74 dc je 107f67 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 107f8b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107f8e: 50 push %eax <== NOT EXECUTED 107f8f: e8 b4 2a 00 00 call 10aa48 <== NOT EXECUTED 0010901c : } } rtems_status_code rtems_termios_ioctl (void *arg) { 10901c: 55 push %ebp <== NOT EXECUTED 10901d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10901f: 57 push %edi <== NOT EXECUTED 109020: 56 push %esi <== NOT EXECUTED 109021: 53 push %ebx <== NOT EXECUTED 109022: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 109025: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 109028: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10902a: 8b 58 28 mov 0x28(%eax),%ebx <== NOT EXECUTED struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer; 10902d: 8b 72 08 mov 0x8(%edx),%esi <== NOT EXECUTED rtems_status_code sc; args->ioctl_return = 0; 109030: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 109037: 6a 00 push $0x0 <== NOT EXECUTED 109039: 6a 00 push $0x0 <== NOT EXECUTED 10903b: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10903e: e8 69 13 00 00 call 10a3ac <== NOT EXECUTED 109043: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) { 109046: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109049: 85 c0 test %eax,%eax <== NOT EXECUTED 10904b: 75 4b jne 109098 <== NOT EXECUTED args->ioctl_return = sc; return sc; } switch (args->command) { 10904d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 109050: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 109053: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 109056: 0f 84 8c 00 00 00 je 1090e8 <== NOT EXECUTED 10905c: 77 4e ja 1090ac <== NOT EXECUTED 10905e: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 109061: 0f 84 71 01 00 00 je 1091d8 <== NOT EXECUTED 109067: 0f 86 27 01 00 00 jbe 109194 <== NOT EXECUTED if (tty->device.setAttributes) (*tty->device.setAttributes)(tty->minor, &tty->termios); break; case RTEMS_IO_TCDRAIN: drainOutput (tty); 10906d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10906f: e8 9c fb ff ff call 108c10 <== NOT EXECUTED /* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; } break; } rtems_semaphore_release (tty->osem); 109074: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109077: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10907a: e8 25 14 00 00 call 10a4a4 <== NOT EXECUTED args->ioctl_return = sc; 10907f: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 109082: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109085: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED 109088: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return sc; } 10908b: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 10908e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109091: 5b pop %ebx <== NOT EXECUTED 109092: 5e pop %esi <== NOT EXECUTED 109093: 5f pop %edi <== NOT EXECUTED 109094: c9 leave <== NOT EXECUTED 109095: c3 ret <== NOT EXECUTED 109096: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_status_code sc; args->ioctl_return = 0; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) { args->ioctl_return = sc; 109098: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10909b: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED break; } rtems_semaphore_release (tty->osem); args->ioctl_return = sc; return sc; } 10909e: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 1090a1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1090a4: 5b pop %ebx <== NOT EXECUTED 1090a5: 5e pop %esi <== NOT EXECUTED 1090a6: 5f pop %edi <== NOT EXECUTED 1090a7: c9 leave <== NOT EXECUTED 1090a8: c3 ret <== NOT EXECUTED 1090a9: 8d 76 00 lea 0x0(%esi),%esi <== 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) { 1090ac: 3d 7f 66 04 40 cmp $0x4004667f,%eax <== NOT EXECUTED 1090b1: 0f 84 fd 00 00 00 je 1091b4 <== NOT EXECUTED 1090b7: 77 5f ja 109118 <== NOT EXECUTED 1090b9: 83 f8 05 cmp $0x5,%eax <== NOT EXECUTED 1090bc: 74 42 je 109100 <== NOT EXECUTED default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { 1090be: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 1090c4: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 1090c7: 8b 80 38 f4 11 00 mov 0x11f438(%eax),%eax <== NOT EXECUTED 1090cd: 85 c0 test %eax,%eax <== NOT EXECUTED 1090cf: 0f 84 ab 02 00 00 je 109380 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); 1090d5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1090d8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1090db: 53 push %ebx <== NOT EXECUTED 1090dc: ff d0 call *%eax <== NOT EXECUTED 1090de: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED 1090e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1090e4: eb 8e jmp 109074 <== NOT EXECUTED 1090e6: 66 90 xchg %ax,%ax <== NOT EXECUTED case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; break; case RTEMS_IO_RCVWAKEUP: tty->tty_rcv = *wakeup; 1090e8: 8b 16 mov (%esi),%edx <== NOT EXECUTED 1090ea: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 1090ed: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx) <== NOT EXECUTED 1090f3: 89 93 dc 00 00 00 mov %edx,0xdc(%ebx) <== NOT EXECUTED 1090f9: e9 76 ff ff ff jmp 109074 <== NOT EXECUTED 1090fe: 66 90 xchg %ax,%ax <== NOT EXECUTED case RTEMS_IO_TCDRAIN: drainOutput (tty); break; case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; 109100: 8b 16 mov (%esi),%edx <== NOT EXECUTED 109102: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 109105: 89 83 d8 00 00 00 mov %eax,0xd8(%ebx) <== NOT EXECUTED 10910b: 89 93 d4 00 00 00 mov %edx,0xd4(%ebx) <== NOT EXECUTED 109111: e9 5e ff ff ff jmp 109074 <== NOT EXECUTED 109116: 66 90 xchg %ax,%ax <== 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) { 109118: 3d 1a 74 04 40 cmp $0x4004741a,%eax <== NOT EXECUTED 10911d: 74 61 je 109180 <== NOT EXECUTED 10911f: 3d 1b 74 04 80 cmp $0x8004741b,%eax <== NOT EXECUTED 109124: 75 98 jne 1090be <== NOT EXECUTED #if 1 /* FIXME */ case TIOCSETD: /* * close old line discipline */ if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 109126: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 10912c: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 10912f: 8b 80 24 f4 11 00 mov 0x11f424(%eax),%eax <== NOT EXECUTED 109135: 85 c0 test %eax,%eax <== NOT EXECUTED 109137: 74 0c je 109145 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_close(tty); 109139: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10913c: 53 push %ebx <== NOT EXECUTED 10913d: ff d0 call *%eax <== NOT EXECUTED 10913f: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED 109142: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } tty->t_line=*(int*)(args->buffer); 109145: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 109148: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10914b: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10914d: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) <== NOT EXECUTED tty->t_sc = NULL; /* ensure that no more valid data */ 109153: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) <== NOT EXECUTED 10915a: 00 00 00 <== NOT EXECUTED /* * open new line discipline */ if (rtems_termios_linesw[tty->t_line].l_open != NULL) { 10915d: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 109160: 8b 80 20 f4 11 00 mov 0x11f420(%eax),%eax <== NOT EXECUTED 109166: 85 c0 test %eax,%eax <== NOT EXECUTED 109168: 0f 84 06 ff ff ff je 109074 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_open(tty); 10916e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109171: 53 push %ebx <== NOT EXECUTED 109172: ff d0 call *%eax <== NOT EXECUTED 109174: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED 109177: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10917a: e9 f5 fe ff ff jmp 109074 <== NOT EXECUTED 10917f: 90 nop <== NOT EXECUTED } break; case TIOCGETD: *(int*)(args->buffer)=tty->t_line; 109180: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 109183: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED 109186: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 10918c: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10918e: e9 e1 fe ff ff jmp 109074 <== NOT EXECUTED 109193: 90 nop <== 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) { 109194: 48 dec %eax <== NOT EXECUTED 109195: 0f 85 23 ff ff ff jne 1090be <== NOT EXECUTED sc = RTEMS_INVALID_NUMBER; } break; case RTEMS_IO_GET_ATTRIBUTES: *(struct termios *)args->buffer = tty->termios; 10919b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10919e: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 1091a1: 8d 73 30 lea 0x30(%ebx),%esi <== NOT EXECUTED 1091a4: b9 09 00 00 00 mov $0x9,%ecx <== NOT EXECUTED 1091a9: 89 c7 mov %eax,%edi <== NOT EXECUTED 1091ab: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1091ad: e9 c2 fe ff ff jmp 109074 <== NOT EXECUTED 1091b2: 66 90 xchg %ax,%ax <== NOT EXECUTED *(int*)(args->buffer)=tty->t_line; break; #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; 1091b4: 8b 53 60 mov 0x60(%ebx),%edx <== NOT EXECUTED 1091b7: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED if ( rawnc < 0 ) 1091ba: 29 c2 sub %eax,%edx <== NOT EXECUTED 1091bc: 0f 88 b2 01 00 00 js 109374 <== NOT EXECUTED rawnc += tty->rawInBuf.Size; /* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; 1091c2: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1091c5: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED 1091c8: 03 53 20 add 0x20(%ebx),%edx <== NOT EXECUTED 1091cb: 2b 53 24 sub 0x24(%ebx),%edx <== NOT EXECUTED 1091ce: 89 10 mov %edx,(%eax) <== NOT EXECUTED 1091d0: e9 9f fe ff ff jmp 109074 <== NOT EXECUTED 1091d5: 8d 76 00 lea 0x0(%esi),%esi <== 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; 1091d8: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1091db: 8b 70 08 mov 0x8(%eax),%esi <== NOT EXECUTED 1091de: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED 1091e1: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED 1091e4: b9 09 00 00 00 mov $0x9,%ecx <== NOT EXECUTED 1091e9: 89 d7 mov %edx,%edi <== NOT EXECUTED 1091eb: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== 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) && 1091ed: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1091f3: f6 c4 02 test $0x2,%ah <== NOT EXECUTED 1091f6: 74 44 je 10923c <== NOT EXECUTED 1091f8: f6 43 31 04 testb $0x4,0x31(%ebx) <== NOT EXECUTED 1091fc: 75 3e jne 10923c <== NOT EXECUTED !(tty->termios.c_iflag & IXON)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF); 1091fe: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109204: 25 ef fd ff ff and $0xfffffdef,%eax <== NOT EXECUTED 109209: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* has output been stopped due to received XOFF? */ if (tty->flow_ctrl & FL_OSTOP) { 10920f: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109215: a8 20 test $0x20,%al <== NOT EXECUTED 109217: 74 23 je 10923c <== NOT EXECUTED /* disable interrupts */ rtems_interrupt_disable(level); 109219: 9c pushf <== NOT EXECUTED 10921a: fa cli <== NOT EXECUTED 10921b: 5e pop %esi <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 10921c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109222: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 109225: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* check for chars in output buffer (or rob_state?) */ if (tty->rawOutBufState != rob_idle) { 10922b: 8b 8b 94 00 00 00 mov 0x94(%ebx),%ecx <== NOT EXECUTED 109231: 85 c9 test %ecx,%ecx <== NOT EXECUTED 109233: 0f 85 7d 01 00 00 jne 1093b6 <== 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); 109239: 56 push %esi <== NOT EXECUTED 10923a: 9d popf <== NOT EXECUTED 10923b: 90 nop <== NOT EXECUTED } } /* check for incoming XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXOF) && 10923c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109242: f6 c4 04 test $0x4,%ah <== NOT EXECUTED 109245: 74 24 je 10926b <== NOT EXECUTED 109247: f6 43 31 10 testb $0x10,0x31(%ebx) <== NOT EXECUTED 10924b: 75 1e jne 10926b <== NOT EXECUTED !(tty->termios.c_iflag & IXOFF)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXOF); 10924d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109253: 80 e4 fb and $0xfb,%ah <== NOT EXECUTED 109256: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* FIXME: what happens, if we had sent XOFF but not yet XON? */ tty->flow_ctrl &= ~(FL_ISNTXOF); 10925c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109262: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 109265: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } /* check for incoming RTS/CTS flow control switched off */ if (( tty->flow_ctrl & FL_MDRTS) && 10926b: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109271: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 109274: 74 48 je 1092be <== NOT EXECUTED 109276: 8b 7b 38 mov 0x38(%ebx),%edi <== NOT EXECUTED 109279: 85 ff test %edi,%edi <== NOT EXECUTED 10927b: 0f 88 0b 01 00 00 js 10938c <== NOT EXECUTED !(tty->termios.c_cflag & CRTSCTS)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDRTS); 109281: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109287: 80 e4 fe and $0xfe,%ah <== NOT EXECUTED 10928a: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED /* restart remote Tx, if it was stopped */ if ((tty->flow_ctrl & FL_IRTSOFF) && 109290: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109296: a8 04 test $0x4,%al <== NOT EXECUTED 109298: 74 15 je 1092af <== NOT EXECUTED 10929a: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 1092a0: 85 c0 test %eax,%eax <== NOT EXECUTED 1092a2: 74 0b je 1092af <== NOT EXECUTED (tty->device.startRemoteTx != NULL)) { tty->device.startRemoteTx(tty->minor); 1092a4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1092a7: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1092aa: ff d0 call *%eax <== NOT EXECUTED 1092ac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } tty->flow_ctrl &= ~(FL_IRTSOFF); 1092af: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1092b5: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 1092b8: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== 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) { 1092be: 8b 73 38 mov 0x38(%ebx),%esi <== NOT EXECUTED 1092c1: 85 f6 test %esi,%esi <== NOT EXECUTED 1092c3: 0f 88 c3 00 00 00 js 10938c <== NOT EXECUTED tty->flow_ctrl |= FL_MDRTS; } /* check for incoming XON/XOF flow control switched on */ if (tty->termios.c_iflag & IXOFF) { 1092c9: 8b 53 30 mov 0x30(%ebx),%edx <== NOT EXECUTED 1092cc: f6 c6 10 test $0x10,%dh <== NOT EXECUTED 1092cf: 74 0f je 1092e0 <== NOT EXECUTED tty->flow_ctrl |= FL_MDXOF; 1092d1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1092d7: 80 cc 04 or $0x4,%ah <== NOT EXECUTED 1092da: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } /* check for outgoing XON/XOF flow control switched on */ if (tty->termios.c_iflag & IXON) { 1092e0: 80 e6 04 and $0x4,%dh <== NOT EXECUTED 1092e3: 74 0f je 1092f4 <== NOT EXECUTED tty->flow_ctrl |= FL_MDXON; 1092e5: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1092eb: 80 cc 02 or $0x2,%ah <== NOT EXECUTED 1092ee: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== 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) { 1092f4: f6 43 3c 02 testb $0x2,0x3c(%ebx) <== NOT EXECUTED 1092f8: 74 36 je 109330 <== NOT EXECUTED else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; } else { if (tty->termios.c_cc[VMIN]) { tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 1092fa: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; 109301: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 109308: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx) <== NOT EXECUTED else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; } } } if (tty->device.setAttributes) 10930f: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax <== NOT EXECUTED 109315: 85 c0 test %eax,%eax <== NOT EXECUTED 109317: 0f 84 57 fd ff ff je 109074 <== NOT EXECUTED (*tty->device.setAttributes)(tty->minor, &tty->termios); 10931d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109320: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 109323: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109326: ff d0 call *%eax <== NOT EXECUTED 109328: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10932b: e9 44 fd ff ff jmp 109074 <== 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); 109330: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109333: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 109336: 50 push %eax <== NOT EXECUTED 109337: 6a 03 push $0x3 <== NOT EXECUTED 109339: e8 8e 07 00 00 call 109acc <== NOT EXECUTED tty->vtimeTicks = tty->termios.c_cc[VTIME] * ticksPerSecond / 10; 10933e: 0f b6 43 46 movzbl 0x46(%ebx),%eax <== NOT EXECUTED 109342: 0f af 45 f0 imul -0x10(%ebp),%eax <== NOT EXECUTED 109346: ba cd cc cc cc mov $0xcccccccd,%edx <== NOT EXECUTED 10934b: f7 e2 mul %edx <== NOT EXECUTED 10934d: c1 ea 03 shr $0x3,%edx <== NOT EXECUTED 109350: 89 53 54 mov %edx,0x54(%ebx) <== NOT EXECUTED if (tty->termios.c_cc[VTIME]) { 109353: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109356: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED 10935a: 74 44 je 1093a0 <== NOT EXECUTED tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 10935c: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = tty->vtimeTicks; 109363: 89 53 70 mov %edx,0x70(%ebx) <== NOT EXECUTED if (tty->termios.c_cc[VMIN]) 109366: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED 10936a: 75 9c jne 109308 <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; 10936c: 89 53 74 mov %edx,0x74(%ebx) <== NOT EXECUTED 10936f: eb 9e jmp 10930f <== NOT EXECUTED 109371: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED #endif case FIONREAD: { int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head; if ( rawnc < 0 ) rawnc += tty->rawInBuf.Size; 109374: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED 109377: 01 c2 add %eax,%edx <== NOT EXECUTED 109379: e9 44 fe ff ff jmp 1091c2 <== NOT EXECUTED 10937e: 66 90 xchg %ax,%ax <== NOT EXECUTED args->ioctl_return = sc; return sc; } switch (args->command) { default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { 109380: c7 45 d4 0a 00 00 00 movl $0xa,-0x2c(%ebp) <== NOT EXECUTED 109387: e9 e8 fc ff ff jmp 109074 <== 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; 10938c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109392: 80 cc 01 or $0x1,%ah <== NOT EXECUTED 109395: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED 10939b: e9 29 ff ff ff jmp 1092c9 <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; } else { if (tty->termios.c_cc[VMIN]) { 1093a0: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED 1093a4: 0f 85 50 ff ff ff jne 1092fa <== NOT EXECUTED tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; 1093aa: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx) <== NOT EXECUTED 1093b1: e9 59 ff ff ff jmp 10930f <== 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, 1093b6: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED 1093bc: 52 push %edx <== NOT EXECUTED 1093bd: 6a 01 push $0x1 <== NOT EXECUTED 1093bf: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 1093c2: 50 push %eax <== NOT EXECUTED 1093c3: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1093c6: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 1093cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1093cf: e9 65 fe ff ff jmp 109239 <== NOT EXECUTED 00109588 : rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) { 109588: 55 push %ebp <== NOT EXECUTED 109589: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10958b: 57 push %edi <== NOT EXECUTED 10958c: 56 push %esi <== NOT EXECUTED 10958d: 53 push %ebx <== NOT EXECUTED 10958e: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED struct rtems_termios_tty *tty; /* * See if the device has already been opened */ sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, 109591: 6a 00 push $0x0 <== NOT EXECUTED 109593: 6a 00 push $0x0 <== NOT EXECUTED 109595: ff 35 ec f6 11 00 pushl 0x11f6ec <== NOT EXECUTED 10959b: e8 0c 0e 00 00 call 10a3ac <== NOT EXECUTED 1095a0: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 1095a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1095a6: 85 c0 test %eax,%eax <== NOT EXECUTED 1095a8: 75 6e jne 109618 <== NOT EXECUTED return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 1095aa: 8b 1d f4 f6 11 00 mov 0x11f6f4,%ebx <== NOT EXECUTED 1095b0: 85 db test %ebx,%ebx <== NOT EXECUTED 1095b2: 75 0a jne 1095be <== NOT EXECUTED 1095b4: eb 6e jmp 109624 <== NOT EXECUTED 1095b6: 66 90 xchg %ax,%ax <== NOT EXECUTED 1095b8: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED 1095ba: 85 db test %ebx,%ebx <== NOT EXECUTED 1095bc: 74 66 je 109624 <== NOT EXECUTED if ((tty->major == major) && (tty->minor == minor)) 1095be: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1095c1: 39 43 0c cmp %eax,0xc(%ebx) <== NOT EXECUTED 1095c4: 75 f2 jne 1095b8 <== NOT EXECUTED 1095c6: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 1095c9: 39 53 10 cmp %edx,0x10(%ebx) <== NOT EXECUTED 1095cc: 75 ea jne 1095b8 <== NOT EXECUTED */ if (c++ == 'z') c = 'a'; } args->iop->data1 = tty; 1095ce: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 1095d1: 8b 07 mov (%edi),%eax <== NOT EXECUTED 1095d3: 89 58 28 mov %ebx,0x28(%eax) <== NOT EXECUTED if (!tty->refcount++) { 1095d6: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 1095d9: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 1095dc: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED 1095df: 85 d2 test %edx,%edx <== NOT EXECUTED 1095e1: 75 24 jne 109607 <== NOT EXECUTED if (tty->device.firstOpen) 1095e3: 8b 83 98 00 00 00 mov 0x98(%ebx),%eax <== NOT EXECUTED 1095e9: 85 c0 test %eax,%eax <== NOT EXECUTED 1095eb: 74 0d je 1095fa <== NOT EXECUTED (*tty->device.firstOpen)(major, minor, arg); 1095ed: 52 push %edx <== NOT EXECUTED 1095ee: 57 push %edi <== NOT EXECUTED 1095ef: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1095f2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1095f5: ff d0 call *%eax <== NOT EXECUTED 1095f7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 1095fa: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) <== NOT EXECUTED 109601: 0f 84 8d 02 00 00 je 109894 <== NOT EXECUTED (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } } rtems_semaphore_release (rtems_termios_ttyMutex); 109607: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10960a: ff 35 ec f6 11 00 pushl 0x11f6ec <== NOT EXECUTED 109610: e8 8f 0e 00 00 call 10a4a4 <== NOT EXECUTED 109615: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109618: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10961b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10961e: 5b pop %ebx <== NOT EXECUTED 10961f: 5e pop %esi <== NOT EXECUTED 109620: 5f pop %edi <== NOT EXECUTED 109621: c9 leave <== NOT EXECUTED 109622: c3 ret <== NOT EXECUTED 109623: 90 nop <== NOT EXECUTED static char c = 'a'; /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); 109624: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109627: 68 e8 00 00 00 push $0xe8 <== NOT EXECUTED 10962c: 6a 01 push $0x1 <== NOT EXECUTED 10962e: e8 c1 4e 00 00 call 10e4f4 <== NOT EXECUTED 109633: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 109636: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (tty == NULL) { 109638: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10963b: 85 c0 test %eax,%eax <== NOT EXECUTED 10963d: 0f 84 b5 02 00 00 je 1098f8 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; 109643: a1 48 d5 11 00 mov 0x11d548,%eax <== NOT EXECUTED 109648: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 10964b: 89 46 64 mov %eax,0x64(%esi) <== NOT EXECUTED tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size); 10964e: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED 109651: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109654: 50 push %eax <== NOT EXECUTED 109655: e8 5e dc ff ff call 1072b8 <== NOT EXECUTED 10965a: 89 46 58 mov %eax,0x58(%esi) <== NOT EXECUTED if (tty->rawInBuf.theBuf == NULL) { 10965d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109660: 85 c0 test %eax,%eax <== NOT EXECUTED 109662: 0f 84 6b 02 00 00 je 1098d3 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate raw output buffer */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; 109668: a1 4c d5 11 00 mov 0x11d54c,%eax <== NOT EXECUTED 10966d: 8b 7d e8 mov -0x18(%ebp),%edi <== NOT EXECUTED 109670: 89 87 88 00 00 00 mov %eax,0x88(%edi) <== NOT EXECUTED tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); 109676: 8b 87 88 00 00 00 mov 0x88(%edi),%eax <== NOT EXECUTED 10967c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10967f: 50 push %eax <== NOT EXECUTED 109680: e8 33 dc ff ff call 1072b8 <== NOT EXECUTED 109685: 89 47 7c mov %eax,0x7c(%edi) <== NOT EXECUTED if (tty->rawOutBuf.theBuf == NULL) { 109688: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10968b: 85 c0 test %eax,%eax <== NOT EXECUTED 10968d: 0f 84 82 02 00 00 je 109915 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); 109693: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109696: ff 35 44 d5 11 00 pushl 0x11d544 <== NOT EXECUTED 10969c: e8 17 dc ff ff call 1072b8 <== NOT EXECUTED 1096a1: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 1096a4: 89 42 1c mov %eax,0x1c(%edx) <== NOT EXECUTED if (tty->cbuf == NULL) { 1096a7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1096aa: 85 c0 test %eax,%eax <== NOT EXECUTED 1096ac: 0f 84 a6 02 00 00 je 109958 <== NOT EXECUTED return RTEMS_NO_MEMORY; } /* * Initialize wakeup callbacks */ tty->tty_snd.sw_pfn = NULL; 1096b2: 8b 7d e8 mov -0x18(%ebp),%edi <== NOT EXECUTED 1096b5: c7 87 d4 00 00 00 00 movl $0x0,0xd4(%edi) <== NOT EXECUTED 1096bc: 00 00 00 <== NOT EXECUTED tty->tty_snd.sw_arg = NULL; 1096bf: c7 87 d8 00 00 00 00 movl $0x0,0xd8(%edi) <== NOT EXECUTED 1096c6: 00 00 00 <== NOT EXECUTED tty->tty_rcv.sw_pfn = NULL; 1096c9: c7 87 dc 00 00 00 00 movl $0x0,0xdc(%edi) <== NOT EXECUTED 1096d0: 00 00 00 <== NOT EXECUTED tty->tty_rcv.sw_arg = NULL; 1096d3: c7 87 e0 00 00 00 00 movl $0x0,0xe0(%edi) <== NOT EXECUTED 1096da: 00 00 00 <== NOT EXECUTED tty->tty_rcvwakeup = 0; 1096dd: c7 87 e4 00 00 00 00 movl $0x0,0xe4(%edi) <== NOT EXECUTED 1096e4: 00 00 00 <== NOT EXECUTED /* * link tty */ tty->forw = rtems_termios_ttyHead; 1096e7: a1 f4 f6 11 00 mov 0x11f6f4,%eax <== NOT EXECUTED 1096ec: 89 07 mov %eax,(%edi) <== NOT EXECUTED tty->back = NULL; 1096ee: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) <== NOT EXECUTED if (rtems_termios_ttyHead != NULL) 1096f5: 85 c0 test %eax,%eax <== NOT EXECUTED 1096f7: 74 03 je 1096fc <== NOT EXECUTED rtems_termios_ttyHead->back = tty; 1096f9: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED rtems_termios_ttyHead = tty; 1096fc: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1096ff: a3 f4 f6 11 00 mov %eax,0x11f6f4 <== NOT EXECUTED if (rtems_termios_ttyTail == NULL) 109704: 8b 35 f0 f6 11 00 mov 0x11f6f0,%esi <== NOT EXECUTED 10970a: 85 f6 test %esi,%esi <== NOT EXECUTED 10970c: 0f 84 d6 02 00 00 je 1099e8 <== NOT EXECUTED rtems_termios_ttyTail = tty; tty->minor = minor; 109712: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 109715: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 109718: 89 72 10 mov %esi,0x10(%edx) <== NOT EXECUTED tty->major = major; 10971b: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10971e: 89 7a 0c mov %edi,0xc(%edx) <== NOT EXECUTED /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 109721: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109724: 89 d0 mov %edx,%eax <== NOT EXECUTED 109726: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 109729: 50 push %eax <== NOT EXECUTED 10972a: 6a 00 push $0x0 <== NOT EXECUTED 10972c: 6a 54 push $0x54 <== NOT EXECUTED 10972e: 6a 01 push $0x1 <== NOT EXECUTED 109730: 0f be 05 50 d5 11 00 movsbl 0x11d550,%eax <== NOT EXECUTED 109737: 0d 00 69 52 54 or $0x54526900,%eax <== NOT EXECUTED 10973c: 50 push %eax <== NOT EXECUTED 10973d: e8 ea 09 00 00 call 10a12c <== NOT EXECUTED 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) 109742: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109745: 85 c0 test %eax,%eax <== NOT EXECUTED 109747: 0f 85 7d 01 00 00 jne 1098ca <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 10974d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109750: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 109753: 83 c0 18 add $0x18,%eax <== NOT EXECUTED 109756: 50 push %eax <== NOT EXECUTED 109757: 6a 00 push $0x0 <== NOT EXECUTED 109759: 6a 54 push $0x54 <== NOT EXECUTED 10975b: 6a 01 push $0x1 <== NOT EXECUTED 10975d: 0f be 05 50 d5 11 00 movsbl 0x11d550,%eax <== NOT EXECUTED 109764: 0d 00 6f 52 54 or $0x54526f00,%eax <== NOT EXECUTED 109769: 50 push %eax <== NOT EXECUTED 10976a: e8 bd 09 00 00 call 10a12c <== NOT EXECUTED 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) 10976f: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109772: 85 c0 test %eax,%eax <== NOT EXECUTED 109774: 0f 85 50 01 00 00 jne 1098ca <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 10977a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10977d: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 109780: 05 8c 00 00 00 add $0x8c,%eax <== NOT EXECUTED 109785: 50 push %eax <== NOT EXECUTED 109786: 6a 00 push $0x0 <== NOT EXECUTED 109788: 6a 20 push $0x20 <== NOT EXECUTED 10978a: 6a 00 push $0x0 <== NOT EXECUTED 10978c: 0f be 05 50 d5 11 00 movsbl 0x11d550,%eax <== NOT EXECUTED 109793: 0d 00 78 52 54 or $0x54527800,%eax <== NOT EXECUTED 109798: 50 push %eax <== NOT EXECUTED 109799: e8 8e 09 00 00 call 10a12c <== NOT EXECUTED rtems_build_name ('T', 'R', 'x', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO, RTEMS_NO_PRIORITY, &tty->rawOutBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 10979e: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1097a1: 85 c0 test %eax,%eax <== NOT EXECUTED 1097a3: 0f 85 21 01 00 00 jne 1098ca <== NOT EXECUTED rtems_fatal_error_occurred (sc); tty->rawOutBufState = rob_idle; 1097a9: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1097ac: c7 80 94 00 00 00 00 movl $0x0,0x94(%eax) <== NOT EXECUTED 1097b3: 00 00 00 <== NOT EXECUTED /* * Set callbacks */ tty->device = *callbacks; 1097b6: 05 98 00 00 00 add $0x98,%eax <== NOT EXECUTED 1097bb: b9 08 00 00 00 mov $0x8,%ecx <== NOT EXECUTED 1097c0: 89 c7 mov %eax,%edi <== NOT EXECUTED 1097c2: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 1097c5: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 1097c7: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1097ca: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax) <== NOT EXECUTED 1097d1: 0f 84 a0 01 00 00 je 109977 <== NOT EXECUTED &tty->rxTaskId); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || 1097d7: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 1097da: 8b 8a a0 00 00 00 mov 0xa0(%edx),%ecx <== NOT EXECUTED 1097e0: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1097e2: 0f 84 3d 01 00 00 je 109925 <== NOT EXECUTED 1097e8: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx) <== NOT EXECUTED 1097ef: 0f 84 30 01 00 00 je 109925 <== NOT EXECUTED } /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; 1097f5: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 1097f8: c7 46 30 02 25 00 00 movl $0x2502,0x30(%esi) <== NOT EXECUTED tty->termios.c_oflag = OPOST | ONLCR | XTABS; 1097ff: c7 46 34 05 18 00 00 movl $0x1805,0x34(%esi) <== NOT EXECUTED tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; 109806: c7 46 38 bd 08 00 00 movl $0x8bd,0x38(%esi) <== NOT EXECUTED tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL; 10980d: c7 46 3c 3b 82 00 00 movl $0x823b,0x3c(%esi) <== NOT EXECUTED tty->termios.c_cc[VINTR] = '\003'; 109814: c6 46 41 03 movb $0x3,0x41(%esi) <== NOT EXECUTED tty->termios.c_cc[VQUIT] = '\034'; 109818: c6 46 42 1c movb $0x1c,0x42(%esi) <== NOT EXECUTED tty->termios.c_cc[VERASE] = '\177'; 10981c: c6 46 43 7f movb $0x7f,0x43(%esi) <== NOT EXECUTED tty->termios.c_cc[VKILL] = '\025'; 109820: c6 46 44 15 movb $0x15,0x44(%esi) <== NOT EXECUTED tty->termios.c_cc[VEOF] = '\004'; 109824: c6 46 45 04 movb $0x4,0x45(%esi) <== NOT EXECUTED tty->termios.c_cc[VEOL] = '\000'; 109828: c6 46 4c 00 movb $0x0,0x4c(%esi) <== NOT EXECUTED tty->termios.c_cc[VEOL2] = '\000'; 10982c: c6 46 51 00 movb $0x0,0x51(%esi) <== NOT EXECUTED tty->termios.c_cc[VSTART] = '\021'; 109830: c6 46 49 11 movb $0x11,0x49(%esi) <== NOT EXECUTED tty->termios.c_cc[VSTOP] = '\023'; 109834: c6 46 4a 13 movb $0x13,0x4a(%esi) <== NOT EXECUTED tty->termios.c_cc[VSUSP] = '\032'; 109838: c6 46 4b 1a movb $0x1a,0x4b(%esi) <== NOT EXECUTED tty->termios.c_cc[VREPRINT] = '\022'; 10983c: c6 46 4d 12 movb $0x12,0x4d(%esi) <== NOT EXECUTED tty->termios.c_cc[VDISCARD] = '\017'; 109840: c6 46 4e 0f movb $0xf,0x4e(%esi) <== NOT EXECUTED tty->termios.c_cc[VWERASE] = '\027'; 109844: c6 46 4f 17 movb $0x17,0x4f(%esi) <== NOT EXECUTED tty->termios.c_cc[VLNEXT] = '\026'; 109848: c6 46 50 16 movb $0x16,0x50(%esi) <== NOT EXECUTED /* start with no flow control, clear flow control flags */ tty->flow_ctrl = 0; 10984c: c7 86 b8 00 00 00 00 movl $0x0,0xb8(%esi) <== NOT EXECUTED 109853: 00 00 00 <== NOT EXECUTED /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2; 109856: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED 109859: d1 e8 shr %eax <== NOT EXECUTED 10985b: 89 86 bc 00 00 00 mov %eax,0xbc(%esi) <== NOT EXECUTED tty->highwater = tty->rawInBuf.Size * 3/4; 109861: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED 109864: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 109867: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED 10986a: 89 86 c0 00 00 00 mov %eax,0xc0(%esi) <== NOT EXECUTED /* * Bump name characer */ if (c++ == 'z') 109870: 8a 15 50 d5 11 00 mov 0x11d550,%dl <== NOT EXECUTED 109876: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 109879: a2 50 d5 11 00 mov %al,0x11d550 <== NOT EXECUTED 10987e: 80 fa 7a cmp $0x7a,%dl <== NOT EXECUTED 109881: 0f 85 47 fd ff ff jne 1095ce <== NOT EXECUTED c = 'a'; 109887: c6 05 50 d5 11 00 61 movb $0x61,0x11d550 <== NOT EXECUTED 10988e: e9 3b fd ff ff jmp 1095ce <== NOT EXECUTED 109893: 90 nop <== NOT EXECUTED (*tty->device.firstOpen)(major, minor, arg); /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { sc = rtems_task_start(tty->rxTaskId, 109894: 57 push %edi <== NOT EXECUTED 109895: 53 push %ebx <== NOT EXECUTED 109896: 68 60 9a 10 00 push $0x109a60 <== NOT EXECUTED 10989b: ff b3 c4 00 00 00 pushl 0xc4(%ebx) <== NOT EXECUTED 1098a1: e8 3e 0f 00 00 call 10a7e4 <== NOT EXECUTED rtems_termios_rxdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 1098a6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1098a9: 85 c0 test %eax,%eax <== NOT EXECUTED 1098ab: 75 1d jne 1098ca <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_task_start(tty->txTaskId, 1098ad: 56 push %esi <== NOT EXECUTED 1098ae: 53 push %ebx <== NOT EXECUTED 1098af: 68 f4 99 10 00 push $0x1099f4 <== NOT EXECUTED 1098b4: ff b3 c8 00 00 00 pushl 0xc8(%ebx) <== NOT EXECUTED 1098ba: e8 25 0f 00 00 call 10a7e4 <== NOT EXECUTED rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 1098bf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1098c2: 85 c0 test %eax,%eax <== NOT EXECUTED 1098c4: 0f 84 3d fd ff ff je 109607 <== NOT EXECUTED rtems_fatal_error_occurred (sc); 1098ca: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1098cd: 50 push %eax <== NOT EXECUTED 1098ce: e8 75 11 00 00 call 10aa48 <== NOT EXECUTED * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size); if (tty->rawInBuf.theBuf == NULL) { free(tty); 1098d3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1098d6: 56 push %esi <== NOT EXECUTED */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); if (tty->rawOutBuf.theBuf == NULL) { free((void *)(tty->rawInBuf.theBuf)); free(tty); 1098d7: e8 c4 d7 ff ff call 1070a0 <== NOT EXECUTED rtems_semaphore_release (rtems_termios_ttyMutex); 1098dc: 58 pop %eax <== NOT EXECUTED 1098dd: ff 35 ec f6 11 00 pushl 0x11f6ec <== NOT EXECUTED 1098e3: e8 bc 0b 00 00 call 10a4a4 <== NOT EXECUTED 1098e8: c7 45 f0 1a 00 00 00 movl $0x1a,-0x10(%ebp) <== NOT EXECUTED 1098ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1098f2: e9 21 fd ff ff jmp 109618 <== NOT EXECUTED 1098f7: 90 nop <== NOT EXECUTED /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); if (tty == NULL) { rtems_semaphore_release (rtems_termios_ttyMutex); 1098f8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1098fb: ff 35 ec f6 11 00 pushl 0x11f6ec <== NOT EXECUTED 109901: e8 9e 0b 00 00 call 10a4a4 <== NOT EXECUTED 109906: c7 45 f0 1a 00 00 00 movl $0x1a,-0x10(%ebp) <== NOT EXECUTED 10990d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109910: e9 03 fd ff ff jmp 109618 <== NOT EXECUTED * allocate raw output buffer */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); if (tty->rawOutBuf.theBuf == NULL) { free((void *)(tty->rawInBuf.theBuf)); 109915: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109918: ff 77 58 pushl 0x58(%edi) <== NOT EXECUTED 10991b: e8 80 d7 ff ff call 1070a0 <== NOT EXECUTED free(tty); 109920: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 109923: eb b2 jmp 1098d7 <== NOT EXECUTED rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 109925: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109928: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10992b: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 10992e: 50 push %eax <== NOT EXECUTED 10992f: 6a 00 push $0x0 <== NOT EXECUTED 109931: 6a 24 push $0x24 <== NOT EXECUTED 109933: 6a 00 push $0x0 <== NOT EXECUTED 109935: 0f be 05 50 d5 11 00 movsbl 0x11d550,%eax <== NOT EXECUTED 10993c: 0d 00 72 52 54 or $0x54527200,%eax <== NOT EXECUTED 109941: 50 push %eax <== NOT EXECUTED 109942: e8 e5 07 00 00 call 10a12c <== 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) 109947: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10994a: 85 c0 test %eax,%eax <== NOT EXECUTED 10994c: 0f 84 a3 fe ff ff je 1097f5 <== NOT EXECUTED 109952: e9 73 ff ff ff jmp 1098ca <== NOT EXECUTED 109957: 90 nop <== NOT EXECUTED /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); if (tty->cbuf == NULL) { free((void *)(tty->rawOutBuf.theBuf)); 109958: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10995b: ff 72 7c pushl 0x7c(%edx) <== NOT EXECUTED 10995e: e8 3d d7 ff ff call 1070a0 <== NOT EXECUTED free((void *)(tty->rawInBuf.theBuf)); 109963: 5f pop %edi <== NOT EXECUTED 109964: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 109967: ff 76 58 pushl 0x58(%esi) <== NOT EXECUTED 10996a: e8 31 d7 ff ff call 1070a0 <== NOT EXECUTED free(tty); 10996f: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 109972: e9 60 ff ff ff jmp 1098d7 <== NOT EXECUTED /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { sc = rtems_task_create ( 109977: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10997a: 05 c8 00 00 00 add $0xc8,%eax <== NOT EXECUTED 10997f: 50 push %eax <== NOT EXECUTED 109980: 6a 00 push $0x0 <== NOT EXECUTED 109982: 68 00 05 00 00 push $0x500 <== NOT EXECUTED 109987: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 10998c: 6a 0a push $0xa <== NOT EXECUTED 10998e: 0f be 05 50 d5 11 00 movsbl 0x11d550,%eax <== NOT EXECUTED 109995: 0d 00 54 78 54 or $0x54785400,%eax <== NOT EXECUTED 10999a: 50 push %eax <== NOT EXECUTED 10999b: e8 a4 0b 00 00 call 10a544 <== 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) 1099a0: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1099a3: 85 c0 test %eax,%eax <== NOT EXECUTED 1099a5: 0f 85 1f ff ff ff jne 1098ca <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_task_create ( 1099ab: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1099ae: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1099b1: 05 c4 00 00 00 add $0xc4,%eax <== NOT EXECUTED 1099b6: 50 push %eax <== NOT EXECUTED 1099b7: 6a 00 push $0x0 <== NOT EXECUTED 1099b9: 68 00 05 00 00 push $0x500 <== NOT EXECUTED 1099be: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 1099c3: 6a 09 push $0x9 <== NOT EXECUTED 1099c5: 0f be 05 50 d5 11 00 movsbl 0x11d550,%eax <== NOT EXECUTED 1099cc: 0d 00 54 78 52 or $0x52785400,%eax <== NOT EXECUTED 1099d1: 50 push %eax <== NOT EXECUTED 1099d2: e8 6d 0b 00 00 call 10a544 <== 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) 1099d7: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1099da: 85 c0 test %eax,%eax <== NOT EXECUTED 1099dc: 0f 84 f5 fd ff ff je 1097d7 <== NOT EXECUTED 1099e2: e9 e3 fe ff ff jmp 1098ca <== NOT EXECUTED 1099e7: 90 nop <== NOT EXECUTED tty->back = NULL; if (rtems_termios_ttyHead != NULL) rtems_termios_ttyHead->back = tty; rtems_termios_ttyHead = tty; if (rtems_termios_ttyTail == NULL) rtems_termios_ttyTail = tty; 1099e8: a3 f0 f6 11 00 mov %eax,0x11f6f0 <== NOT EXECUTED 1099ed: e9 20 fd ff ff jmp 109712 <== NOT EXECUTED 0010854c : * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, int len, struct rtems_termios_tty *tty) { 10854c: 55 push %ebp <== NOT EXECUTED 10854d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10854f: 57 push %edi <== NOT EXECUTED 108550: 56 push %esi <== NOT EXECUTED 108551: 53 push %ebx <== NOT EXECUTED 108552: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 108555: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108558: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10855b: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 10855e: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED const unsigned char *buf = _buf; 108561: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { 108564: 8b 8b b4 00 00 00 mov 0xb4(%ebx),%ecx <== NOT EXECUTED 10856a: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10856c: 0f 84 e6 00 00 00 je 108658 <== NOT EXECUTED (*tty->device.write)(tty->minor, (void *)buf, len); return; } newHead = tty->rawOutBuf.Head; 108572: 8b bb 80 00 00 00 mov 0x80(%ebx),%edi <== NOT EXECUTED 108578: 89 7d f0 mov %edi,-0x10(%ebp) <== NOT EXECUTED while (len) { 10857b: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10857e: 85 c0 test %eax,%eax <== NOT EXECUTED 108580: 0f 84 ed 00 00 00 je 108673 <== NOT EXECUTED * len -= ncopy * * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size; 108586: 8b 75 f0 mov -0x10(%ebp),%esi <== NOT EXECUTED 108589: 46 inc %esi <== NOT EXECUTED 10858a: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx <== NOT EXECUTED 108590: 89 f0 mov %esi,%eax <== NOT EXECUTED 108592: 31 d2 xor %edx,%edx <== NOT EXECUTED 108594: f7 f1 div %ecx <== NOT EXECUTED 108596: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED 108599: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED rtems_interrupt_disable (level); 10859c: 9c pushf <== NOT EXECUTED 10859d: fa cli <== NOT EXECUTED 10859e: 5e pop %esi <== NOT EXECUTED while (newHead == tty->rawOutBuf.Tail) { 10859f: 8b bb 84 00 00 00 mov 0x84(%ebx),%edi <== NOT EXECUTED 1085a5: 39 d7 cmp %edx,%edi <== NOT EXECUTED 1085a7: 75 33 jne 1085dc <== NOT EXECUTED 1085a9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED tty->rawOutBufState = rob_wait; 1085ac: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) <== NOT EXECUTED 1085b3: 00 00 00 <== NOT EXECUTED rtems_interrupt_enable (level); 1085b6: 56 push %esi <== NOT EXECUTED 1085b7: 9d popf <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, 1085b8: 50 push %eax <== NOT EXECUTED 1085b9: 6a 00 push $0x0 <== NOT EXECUTED 1085bb: 6a 00 push $0x0 <== NOT EXECUTED 1085bd: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED 1085c3: e8 e4 1d 00 00 call 10a3ac <== NOT EXECUTED RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 1085c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1085cb: 85 c0 test %eax,%eax <== NOT EXECUTED 1085cd: 75 65 jne 108634 <== NOT EXECUTED rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); 1085cf: 9c pushf <== NOT EXECUTED 1085d0: fa cli <== NOT EXECUTED 1085d1: 5e pop %esi <== 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) { 1085d2: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED 1085d8: 39 f8 cmp %edi,%eax <== NOT EXECUTED 1085da: 74 d0 je 1085ac <== 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++; 1085dc: 8b 8b 80 00 00 00 mov 0x80(%ebx),%ecx <== NOT EXECUTED 1085e2: 8b 53 7c mov 0x7c(%ebx),%edx <== NOT EXECUTED 1085e5: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 1085e8: 8a 07 mov (%edi),%al <== NOT EXECUTED 1085ea: 88 04 0a mov %al,(%edx,%ecx,1) <== NOT EXECUTED tty->rawOutBuf.Head = newHead; 1085ed: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 1085f0: 89 83 80 00 00 00 mov %eax,0x80(%ebx) <== NOT EXECUTED if (tty->rawOutBufState == rob_idle) { 1085f6: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax <== NOT EXECUTED 1085fc: 85 c0 test %eax,%eax <== NOT EXECUTED 1085fe: 75 23 jne 108623 <== NOT EXECUTED /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { 108600: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108606: a8 10 test $0x10,%al <== NOT EXECUTED 108608: 74 33 je 10863d <== 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; 10860a: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108610: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 108613: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } tty->rawOutBufState = rob_busy; 108619: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED 108620: 00 00 00 <== NOT EXECUTED } rtems_interrupt_enable (level); 108623: 56 push %esi <== NOT EXECUTED 108624: 9d popf <== NOT EXECUTED if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, (void *)buf, len); return; } newHead = tty->rawOutBuf.Head; while (len) { 108625: ff 4d e8 decl -0x18(%ebp) <== NOT EXECUTED 108628: 74 49 je 108673 <== 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++; 10862a: ff 45 ec incl -0x14(%ebp) <== NOT EXECUTED 10862d: e9 54 ff ff ff jmp 108586 <== NOT EXECUTED 108632: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_interrupt_enable (level); sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); 108634: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108637: 50 push %eax <== NOT EXECUTED 108638: e8 0b 24 00 00 call 10aa48 <== 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, 10863d: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED 108643: 57 push %edi <== NOT EXECUTED 108644: 6a 01 push $0x1 <== NOT EXECUTED 108646: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 108649: 50 push %eax <== NOT EXECUTED 10864a: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10864d: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 108653: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108656: eb c1 jmp 108619 <== 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); 108658: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED 10865b: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10865e: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 108661: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 108664: 8b 8b a4 00 00 00 mov 0xa4(%ebx),%ecx <== NOT EXECUTED tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 10866a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10866d: 5b pop %ebx <== NOT EXECUTED 10866e: 5e pop %esi <== NOT EXECUTED 10866f: 5f pop %edi <== NOT EXECUTED 108670: c9 leave <== 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); 108671: ff e1 jmp *%ecx <== NOT EXECUTED tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 108673: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108676: 5b pop %ebx <== NOT EXECUTED 108677: 5e pop %esi <== NOT EXECUTED 108678: 5f pop %edi <== NOT EXECUTED 108679: c9 leave <== NOT EXECUTED 10867a: c3 ret <== NOT EXECUTED 00108c84 : return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) { 108c84: 55 push %ebp <== NOT EXECUTED 108c85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108c87: 57 push %edi <== NOT EXECUTED 108c88: 56 push %esi <== NOT EXECUTED 108c89: 53 push %ebx <== NOT EXECUTED 108c8a: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 108c8d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 108c90: 8b 02 mov (%edx),%eax <== NOT EXECUTED 108c92: 8b 70 28 mov 0x28(%eax),%esi <== NOT EXECUTED uint32_t count = args->count; 108c95: 8b 4a 0c mov 0xc(%edx),%ecx <== NOT EXECUTED 108c98: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED char *buffer = args->buffer; 108c9b: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 108c9e: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED rtems_status_code sc; sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 108ca1: 6a 00 push $0x0 <== NOT EXECUTED 108ca3: 6a 00 push $0x0 <== NOT EXECUTED 108ca5: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 108ca8: e8 ff 16 00 00 call 10a3ac <== NOT EXECUTED 108cad: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 108cb0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108cb3: 85 c0 test %eax,%eax <== NOT EXECUTED 108cb5: 75 35 jne 108cec <== NOT EXECUTED return sc; if (rtems_termios_linesw[tty->t_line].l_read != NULL) { 108cb7: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED 108cbd: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 108cc0: 8b 80 28 f4 11 00 mov 0x11f428(%eax),%eax <== NOT EXECUTED 108cc6: 85 c0 test %eax,%eax <== NOT EXECUTED 108cc8: 74 2e je 108cf8 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_read(tty,args); 108cca: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 108ccd: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 108cd0: 56 push %esi <== NOT EXECUTED 108cd1: ff d0 call *%eax <== NOT EXECUTED 108cd3: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED tty->tty_rcvwakeup = 0; 108cd6: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) <== NOT EXECUTED 108cdd: 00 00 00 <== NOT EXECUTED rtems_semaphore_release (tty->isem); 108ce0: 5b pop %ebx <== NOT EXECUTED 108ce1: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 108ce4: e8 bb 17 00 00 call 10a4a4 <== NOT EXECUTED 108ce9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } args->bytes_moved = args->count - count; tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); return sc; } 108cec: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 108cef: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108cf2: 5b pop %ebx <== NOT EXECUTED 108cf3: 5e pop %esi <== NOT EXECUTED 108cf4: 5f pop %edi <== NOT EXECUTED 108cf5: c9 leave <== NOT EXECUTED 108cf6: c3 ret <== NOT EXECUTED 108cf7: 90 nop <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_read(tty,args); tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); return sc; } if (tty->cindex == tty->ccount) { 108cf8: 8b 46 24 mov 0x24(%esi),%eax <== NOT EXECUTED 108cfb: 3b 46 20 cmp 0x20(%esi),%eax <== NOT EXECUTED 108cfe: 74 60 je 108d60 <== NOT EXECUTED else sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 108d00: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 108d03: 85 c0 test %eax,%eax <== NOT EXECUTED 108d05: 74 2a je 108d31 <== NOT EXECUTED 108d07: 8b 56 24 mov 0x24(%esi),%edx <== NOT EXECUTED 108d0a: 3b 56 20 cmp 0x20(%esi),%edx <== NOT EXECUTED 108d0d: 7c 0a jl 108d19 <== NOT EXECUTED 108d0f: eb 20 jmp 108d31 <== NOT EXECUTED 108d11: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 108d14: 39 56 20 cmp %edx,0x20(%esi) <== NOT EXECUTED 108d17: 7e 18 jle 108d31 <== NOT EXECUTED *buffer++ = tty->cbuf[tty->cindex++]; 108d19: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 108d1c: 8a 04 10 mov (%eax,%edx,1),%al <== NOT EXECUTED 108d1f: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED 108d22: 88 01 mov %al,(%ecx) <== NOT EXECUTED 108d24: 41 inc %ecx <== NOT EXECUTED 108d25: 89 4d d4 mov %ecx,-0x2c(%ebp) <== NOT EXECUTED 108d28: 42 inc %edx <== NOT EXECUTED 108d29: 89 56 24 mov %edx,0x24(%esi) <== NOT EXECUTED else sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 108d2c: ff 4d d0 decl -0x30(%ebp) <== NOT EXECUTED 108d2f: 75 e3 jne 108d14 <== NOT EXECUTED *buffer++ = tty->cbuf[tty->cindex++]; count--; } args->bytes_moved = args->count - count; 108d31: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 108d34: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 108d37: 2b 45 d0 sub -0x30(%ebp),%eax <== NOT EXECUTED 108d3a: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED tty->tty_rcvwakeup = 0; 108d3d: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) <== NOT EXECUTED 108d44: 00 00 00 <== NOT EXECUTED rtems_semaphore_release (tty->isem); 108d47: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108d4a: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 108d4d: e8 52 17 00 00 call 10a4a4 <== NOT EXECUTED 108d52: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return sc; } 108d55: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 108d58: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108d5b: 5b pop %ebx <== NOT EXECUTED 108d5c: 5e pop %esi <== NOT EXECUTED 108d5d: 5f pop %edi <== NOT EXECUTED 108d5e: c9 leave <== NOT EXECUTED 108d5f: c3 ret <== NOT EXECUTED tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); return sc; } if (tty->cindex == tty->ccount) { tty->cindex = tty->ccount = 0; 108d60: c7 46 20 00 00 00 00 movl $0x0,0x20(%esi) <== NOT EXECUTED 108d67: c7 46 24 00 00 00 00 movl $0x0,0x24(%esi) <== NOT EXECUTED tty->read_start_column = tty->column; 108d6e: 8b 46 28 mov 0x28(%esi),%eax <== NOT EXECUTED 108d71: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED if (tty->device.pollRead != NULL 108d74: 8b 86 a0 00 00 00 mov 0xa0(%esi),%eax <== NOT EXECUTED 108d7a: 89 c2 mov %eax,%edx <== NOT EXECUTED 108d7c: 85 c0 test %eax,%eax <== NOT EXECUTED 108d7e: 74 0e je 108d8e <== NOT EXECUTED 108d80: 8b 8e b4 00 00 00 mov 0xb4(%esi),%ecx <== NOT EXECUTED 108d86: 85 c9 test %ecx,%ecx <== NOT EXECUTED 108d88: 0f 84 69 01 00 00 je 108ef7 <== 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; 108d8e: 8b 5e 74 mov 0x74(%esi),%ebx <== 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, 108d91: 8d 56 49 lea 0x49(%esi),%edx <== NOT EXECUTED 108d94: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED 108d97: c7 45 dc 01 00 00 00 movl $0x1,-0x24(%ebp) <== NOT EXECUTED 108d9e: 66 90 xchg %ax,%ax <== NOT EXECUTED while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 108da0: 8b 56 5c mov 0x5c(%esi),%edx <== NOT EXECUTED 108da3: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED 108da6: 39 c2 cmp %eax,%edx <== NOT EXECUTED 108da8: 75 2e jne 108dd8 <== NOT EXECUTED 108daa: e9 f1 00 00 00 jmp 108ea0 <== NOT EXECUTED 108daf: 90 nop <== NOT EXECUTED } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { if (siproc (c, tty)) 108db0: 89 fa mov %edi,%edx <== NOT EXECUTED 108db2: 0f b6 c2 movzbl %dl,%eax <== NOT EXECUTED 108db5: 89 f2 mov %esi,%edx <== NOT EXECUTED 108db7: e8 30 fd ff ff call 108aec <== NOT EXECUTED 108dbc: 85 c0 test %eax,%eax <== NOT EXECUTED 108dbe: 74 07 je 108dc7 <== NOT EXECUTED wait = 0; } else { siproc (c, tty); if (tty->ccount >= tty->termios.c_cc[VMIN]) 108dc0: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED wait = 0; } timeout = tty->rawInBufSemaphoreTimeout; 108dc7: 8b 5e 70 mov 0x70(%esi),%ebx <== NOT EXECUTED while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 108dca: 8b 56 5c mov 0x5c(%esi),%edx <== NOT EXECUTED 108dcd: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED 108dd0: 39 c2 cmp %eax,%edx <== NOT EXECUTED 108dd2: 0f 84 c8 00 00 00 je 108ea0 <== NOT EXECUTED 108dd8: a1 44 d5 11 00 mov 0x11d544,%eax <== NOT EXECUTED 108ddd: 48 dec %eax <== NOT EXECUTED 108dde: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED 108de1: 0f 8d b9 00 00 00 jge 108ea0 <== NOT EXECUTED (tty->ccount < (CBUFSIZE-1))) { unsigned char c; unsigned int newHead; newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size; 108de7: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED 108dea: 8b 56 64 mov 0x64(%esi),%edx <== NOT EXECUTED 108ded: 40 inc %eax <== NOT EXECUTED 108dee: 89 d1 mov %edx,%ecx <== NOT EXECUTED 108df0: 31 d2 xor %edx,%edx <== NOT EXECUTED 108df2: f7 f1 div %ecx <== NOT EXECUTED c = tty->rawInBuf.theBuf[newHead]; 108df4: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED 108df7: 0f b6 3c 10 movzbl (%eax,%edx,1),%edi <== NOT EXECUTED tty->rawInBuf.Head = newHead; 108dfb: 89 56 5c mov %edx,0x5c(%esi) <== NOT EXECUTED if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 108dfe: 8b 5e 60 mov 0x60(%esi),%ebx <== NOT EXECUTED 108e01: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED 108e04: 8b 4e 64 mov 0x64(%esi),%ecx <== NOT EXECUTED 108e07: 01 d8 add %ebx,%eax <== NOT EXECUTED 108e09: 29 d0 sub %edx,%eax <== NOT EXECUTED 108e0b: 31 d2 xor %edx,%edx <== NOT EXECUTED 108e0d: f7 f1 div %ecx <== NOT EXECUTED 108e0f: 3b 96 bc 00 00 00 cmp 0xbc(%esi),%edx <== NOT EXECUTED 108e15: 73 55 jae 108e6c <== NOT EXECUTED % tty->rawInBuf.Size) < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; 108e17: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108e1d: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 108e20: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED /* if tx stopped and XON should be sent... */ if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF)) 108e26: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108e2c: 25 02 02 00 00 and $0x202,%eax <== NOT EXECUTED 108e31: 3d 02 02 00 00 cmp $0x202,%eax <== NOT EXECUTED 108e36: 0f 84 8c 00 00 00 je 108ec8 <== 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) { 108e3c: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108e42: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 108e45: 74 25 je 108e6c <== NOT EXECUTED tty->flow_ctrl &= ~FL_IRTSOFF; 108e47: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108e4d: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 108e50: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED /* activate RTS line */ if (tty->device.startRemoteTx != NULL) { 108e56: 8b 86 b0 00 00 00 mov 0xb0(%esi),%eax <== NOT EXECUTED 108e5c: 85 c0 test %eax,%eax <== NOT EXECUTED 108e5e: 74 0c je 108e6c <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 108e60: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108e63: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 108e66: ff d0 call *%eax <== NOT EXECUTED 108e68: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108e6b: 90 nop <== NOT EXECUTED } } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { 108e6c: f6 46 3c 02 testb $0x2,0x3c(%esi) <== NOT EXECUTED 108e70: 0f 85 3a ff ff ff jne 108db0 <== NOT EXECUTED if (siproc (c, tty)) wait = 0; } else { siproc (c, tty); 108e76: 89 f9 mov %edi,%ecx <== NOT EXECUTED 108e78: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 108e7b: 89 f2 mov %esi,%edx <== NOT EXECUTED 108e7d: e8 6a fc ff ff call 108aec <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 108e82: 0f b6 46 47 movzbl 0x47(%esi),%eax <== NOT EXECUTED 108e86: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED 108e89: 0f 8d 31 ff ff ff jge 108dc0 <== NOT EXECUTED wait = 0; } timeout = tty->rawInBufSemaphoreTimeout; 108e8f: 8b 5e 70 mov 0x70(%esi),%ebx <== NOT EXECUTED while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 108e92: 8b 56 5c mov 0x5c(%esi),%edx <== NOT EXECUTED 108e95: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED 108e98: 39 c2 cmp %eax,%edx <== NOT EXECUTED 108e9a: 0f 85 38 ff ff ff jne 108dd8 <== NOT EXECUTED } /* * Wait for characters */ if ( wait ) { 108ea0: 8b 4d dc mov -0x24(%ebp),%ecx <== NOT EXECUTED 108ea3: 85 c9 test %ecx,%ecx <== NOT EXECUTED 108ea5: 0f 84 55 fe ff ff je 108d00 <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore, 108eab: 52 push %edx <== NOT EXECUTED 108eac: 53 push %ebx <== NOT EXECUTED 108ead: ff 76 6c pushl 0x6c(%esi) <== NOT EXECUTED 108eb0: ff 76 68 pushl 0x68(%esi) <== NOT EXECUTED 108eb3: e8 f4 14 00 00 call 10a3ac <== NOT EXECUTED tty->rawInBufSemaphoreOptions, timeout); if (sc != RTEMS_SUCCESSFUL) 108eb8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108ebb: 85 c0 test %eax,%eax <== NOT EXECUTED 108ebd: 0f 84 dd fe ff ff je 108da0 <== NOT EXECUTED 108ec3: e9 38 fe ff ff jmp 108d00 <== 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)) 108ec8: 8b 86 94 00 00 00 mov 0x94(%esi),%eax <== NOT EXECUTED 108ece: 85 c0 test %eax,%eax <== NOT EXECUTED 108ed0: 74 0e je 108ee0 <== NOT EXECUTED 108ed2: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108ed8: a8 20 test $0x20,%al <== NOT EXECUTED 108eda: 0f 84 5c ff ff ff je 108e3c <== 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, 108ee0: 53 push %ebx <== NOT EXECUTED 108ee1: 6a 01 push $0x1 <== NOT EXECUTED 108ee3: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 108ee6: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 108ee9: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED 108eef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108ef2: e9 75 ff ff ff jmp 108e6c <== NOT EXECUTED static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 108ef7: f6 46 3c 02 testb $0x2,0x3c(%esi) <== NOT EXECUTED 108efb: 0f 85 bf 00 00 00 jne 108fc0 <== NOT EXECUTED } } } else { rtems_interval then, now; if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 108f01: 80 7e 47 00 cmpb $0x0,0x47(%esi) <== NOT EXECUTED 108f05: 75 1d jne 108f24 <== NOT EXECUTED 108f07: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED 108f0b: 74 17 je 108f24 <== NOT EXECUTED rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then); 108f0d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 108f10: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 108f13: 50 push %eax <== NOT EXECUTED 108f14: 6a 02 push $0x2 <== NOT EXECUTED 108f16: e8 b1 0b 00 00 call 109acc <== NOT EXECUTED 108f1b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f1e: 8b 86 a0 00 00 00 mov 0xa0(%esi),%eax <== 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); 108f24: 8d 7d f0 lea -0x10(%ebp),%edi <== NOT EXECUTED } } else { if (!tty->termios.c_cc[VTIME]) break; rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now); 108f27: 8d 5d ec lea -0x14(%ebp),%ebx <== NOT EXECUTED 108f2a: 66 90 xchg %ax,%ax <== 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); 108f2c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108f2f: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 108f32: ff d0 call *%eax <== NOT EXECUTED if (n < 0) { 108f34: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f37: 85 c0 test %eax,%eax <== NOT EXECUTED 108f39: 79 3f jns 108f7a <== NOT EXECUTED if (tty->termios.c_cc[VMIN]) { 108f3b: 80 7e 47 00 cmpb $0x0,0x47(%esi) <== NOT EXECUTED 108f3f: 0f 84 9b 00 00 00 je 108fe0 <== NOT EXECUTED if (tty->termios.c_cc[VTIME] && tty->ccount) { 108f45: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED 108f49: 74 0d je 108f58 <== NOT EXECUTED 108f4b: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 108f4e: 85 c0 test %eax,%eax <== NOT EXECUTED 108f50: 0f 85 94 00 00 00 jne 108fea <== NOT EXECUTED 108f56: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now); if ((now - then) > tty->vtimeTicks) { break; } } rtems_task_wake_after (1); 108f58: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108f5b: 6a 01 push $0x1 <== NOT EXECUTED 108f5d: e8 f6 18 00 00 call 10a858 <== NOT EXECUTED 108f62: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f65: 8b 86 a0 00 00 00 mov 0xa0(%esi),%eax <== 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); 108f6b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108f6e: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 108f71: ff d0 call *%eax <== NOT EXECUTED if (n < 0) { 108f73: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f76: 85 c0 test %eax,%eax <== NOT EXECUTED 108f78: 78 c1 js 108f3b <== NOT EXECUTED } } rtems_task_wake_after (1); } else { siproc (n, tty); 108f7a: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 108f7d: 89 f2 mov %esi,%edx <== NOT EXECUTED 108f7f: e8 68 fb ff ff call 108aec <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 108f84: 8a 56 47 mov 0x47(%esi),%dl <== NOT EXECUTED 108f87: 0f b6 c2 movzbl %dl,%eax <== NOT EXECUTED 108f8a: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED 108f8d: 0f 8d 6d fd ff ff jge 108d00 <== NOT EXECUTED break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 108f93: 84 d2 test %dl,%dl <== NOT EXECUTED 108f95: 74 06 je 108f9d <== NOT EXECUTED 108f97: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED 108f9b: 75 6f jne 10900c <== NOT EXECUTED 108f9d: 8b 86 a0 00 00 00 mov 0xa0(%esi),%eax <== NOT EXECUTED 108fa3: eb 87 jmp 108f2c <== NOT EXECUTED 108fa5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED n = (*tty->device.pollRead)(tty->minor); if (n < 0) { rtems_task_wake_after (1); } else { if (siproc (n, tty)) 108fa8: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 108fab: 89 f2 mov %esi,%edx <== NOT EXECUTED 108fad: e8 3a fb ff ff call 108aec <== NOT EXECUTED 108fb2: 85 c0 test %eax,%eax <== NOT EXECUTED 108fb4: 0f 85 46 fd ff ff jne 108d00 <== NOT EXECUTED static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 108fba: 8b 96 a0 00 00 00 mov 0xa0(%esi),%edx <== NOT EXECUTED for (;;) { n = (*tty->device.pollRead)(tty->minor); 108fc0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108fc3: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 108fc6: ff d2 call *%edx <== NOT EXECUTED if (n < 0) { 108fc8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108fcb: 85 c0 test %eax,%eax <== NOT EXECUTED 108fcd: 79 d9 jns 108fa8 <== NOT EXECUTED rtems_task_wake_after (1); 108fcf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108fd2: 6a 01 push $0x1 <== NOT EXECUTED 108fd4: e8 7f 18 00 00 call 10a858 <== NOT EXECUTED 108fd9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108fdc: eb dc jmp 108fba <== NOT EXECUTED 108fde: 66 90 xchg %ax,%ax <== NOT EXECUTED break; } } } else { if (!tty->termios.c_cc[VTIME]) 108fe0: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED 108fe4: 0f 84 16 fd ff ff je 108d00 <== NOT EXECUTED break; rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now); 108fea: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 108fed: 53 push %ebx <== NOT EXECUTED 108fee: 6a 02 push $0x2 <== NOT EXECUTED 108ff0: e8 d7 0a 00 00 call 109acc <== NOT EXECUTED if ((now - then) > tty->vtimeTicks) { 108ff5: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 108ff8: 2b 45 f0 sub -0x10(%ebp),%eax <== NOT EXECUTED 108ffb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108ffe: 3b 46 54 cmp 0x54(%esi),%eax <== NOT EXECUTED 109001: 0f 86 51 ff ff ff jbe 108f58 <== NOT EXECUTED 109007: e9 f4 fc ff ff jmp 108d00 <== 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); 10900c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10900f: 57 push %edi <== NOT EXECUTED 109010: 6a 02 push $0x2 <== NOT EXECUTED 109012: e8 b5 0a 00 00 call 109acc <== NOT EXECUTED 109017: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10901a: eb 81 jmp 108f9d <== NOT EXECUTED 00107fd0 : * 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) { 107fd0: 55 push %ebp <== NOT EXECUTED 107fd1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107fd3: 57 push %edi <== NOT EXECUTED 107fd4: 56 push %esi <== NOT EXECUTED 107fd5: 53 push %ebx <== NOT EXECUTED 107fd6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107fd9: 8b 5d 08 mov 0x8(%ebp),%ebx <== 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)) 107fdc: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 107fe2: 25 03 04 00 00 and $0x403,%eax <== NOT EXECUTED 107fe7: 3d 01 04 00 00 cmp $0x401,%eax <== NOT EXECUTED 107fec: 0f 84 02 01 00 00 je 1080f4 <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; rtems_interrupt_enable(level); nToSend = 1; } else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) 107ff2: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 107ff8: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 107ffb: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 107ffe: 0f 84 84 01 00 00 je 108188 <== NOT EXECUTED rtems_interrupt_enable(level); nToSend = 1; } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { 108004: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx <== NOT EXECUTED 10800a: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED 108010: 39 c2 cmp %eax,%edx <== NOT EXECUTED 108012: 0f 84 b4 00 00 00 je 1080cc <== NOT EXECUTED rtems_semaphore_release (tty->rawOutBuf.Semaphore); } return 0; } rtems_interrupt_disable(level); 108018: 9c pushf <== NOT EXECUTED 108019: fa cli <== NOT EXECUTED 10801a: 58 pop %eax <== NOT EXECUTED len = tty->t_dqlen; 10801b: 8b 8b 90 00 00 00 mov 0x90(%ebx),%ecx <== NOT EXECUTED tty->t_dqlen = 0; 108021: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx) <== NOT EXECUTED 108028: 00 00 00 <== NOT EXECUTED rtems_interrupt_enable(level); 10802b: 50 push %eax <== NOT EXECUTED 10802c: 9d popf <== NOT EXECUTED newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size; 10802d: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx <== NOT EXECUTED 108033: 8b b3 88 00 00 00 mov 0x88(%ebx),%esi <== NOT EXECUTED 108039: 01 d1 add %edx,%ecx <== NOT EXECUTED 10803b: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10803d: 31 d2 xor %edx,%edx <== NOT EXECUTED 10803f: f7 f6 div %esi <== NOT EXECUTED 108041: 89 d7 mov %edx,%edi <== NOT EXECUTED tty->rawOutBuf.Tail = newTail; 108043: 89 93 84 00 00 00 mov %edx,0x84(%ebx) <== NOT EXECUTED if (tty->rawOutBufState == rob_wait) { 108049: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) <== NOT EXECUTED 108050: 0f 84 6e 01 00 00 je 1081c4 <== NOT EXECUTED /* * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); } if (newTail == tty->rawOutBuf.Head) { 108056: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax <== NOT EXECUTED 10805c: 39 f8 cmp %edi,%eax <== NOT EXECUTED 10805e: 0f 84 cc 00 00 00 je 108130 <== 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)) 108064: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10806a: 25 10 02 00 00 and $0x210,%eax <== NOT EXECUTED 10806f: 3d 10 02 00 00 cmp $0x210,%eax <== NOT EXECUTED 108074: 0f 84 e6 00 00 00 je 108160 <== NOT EXECUTED } else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) 10807a: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax <== NOT EXECUTED 108080: 39 c7 cmp %eax,%edi <== NOT EXECUTED 108082: 77 64 ja 1080e8 <== NOT EXECUTED nToSend = tty->rawOutBuf.Size - newTail; else nToSend = tty->rawOutBuf.Head - newTail; 108084: 8b b3 80 00 00 00 mov 0x80(%ebx),%esi <== NOT EXECUTED 10808a: 29 fe sub %edi,%esi <== 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)) { 10808c: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108092: f6 c4 06 test $0x6,%ah <== NOT EXECUTED 108095: 74 05 je 10809c <== NOT EXECUTED 108097: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED nToSend = 1; } tty->rawOutBufState = rob_busy; /*apm*/ 10809c: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED 1080a3: 00 00 00 <== NOT EXECUTED (*tty->device.write)(tty->minor, 1080a6: 50 push %eax <== NOT EXECUTED 1080a7: 56 push %esi <== NOT EXECUTED 1080a8: 8b 43 7c mov 0x7c(%ebx),%eax <== NOT EXECUTED 1080ab: 01 f8 add %edi,%eax <== NOT EXECUTED 1080ad: 50 push %eax <== NOT EXECUTED 1080ae: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1080b1: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 1080b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ 1080ba: 89 bb 84 00 00 00 mov %edi,0x84(%ebx) <== NOT EXECUTED } return nToSend; } 1080c0: 89 f0 mov %esi,%eax <== NOT EXECUTED 1080c2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1080c5: 5b pop %ebx <== NOT EXECUTED 1080c6: 5e pop %esi <== NOT EXECUTED 1080c7: 5f pop %edi <== NOT EXECUTED 1080c8: c9 leave <== NOT EXECUTED 1080c9: c3 ret <== NOT EXECUTED 1080ca: 66 90 xchg %ax,%ax <== NOT EXECUTED else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { /* * buffer was empty */ if (tty->rawOutBufState == rob_wait) { 1080cc: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) <== NOT EXECUTED 1080d3: 0f 84 03 01 00 00 je 1081dc <== NOT EXECUTED 1080d9: 31 f6 xor %esi,%esi <== NOT EXECUTED nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 1080db: 89 f0 mov %esi,%eax <== NOT EXECUTED 1080dd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1080e0: 5b pop %ebx <== NOT EXECUTED 1080e1: 5e pop %esi <== NOT EXECUTED 1080e2: 5f pop %edi <== NOT EXECUTED 1080e3: c9 leave <== NOT EXECUTED 1080e4: c3 ret <== NOT EXECUTED 1080e5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) nToSend = tty->rawOutBuf.Size - newTail; 1080e8: 8b b3 88 00 00 00 mov 0x88(%ebx),%esi <== NOT EXECUTED 1080ee: 29 fe sub %edi,%esi <== NOT EXECUTED 1080f0: eb 9a jmp 10808c <== NOT EXECUTED 1080f2: 66 90 xchg %ax,%ax <== 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, 1080f4: 51 push %ecx <== NOT EXECUTED 1080f5: 6a 01 push $0x1 <== NOT EXECUTED 1080f7: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED 1080fa: 50 push %eax <== NOT EXECUTED 1080fb: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1080fe: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTOP]), 1); rtems_interrupt_disable(level); 108104: 9c pushf <== NOT EXECUTED 108105: fa cli <== NOT EXECUTED 108106: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 108107: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 10810d: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108113: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 108116: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 10811c: 52 push %edx <== NOT EXECUTED 10811d: 9d popf <== NOT EXECUTED 10811e: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 108123: 83 c4 10 add $0x10,%esp <== NOT EXECUTED nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 108126: 89 f0 mov %esi,%eax <== NOT EXECUTED 108128: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10812b: 5b pop %ebx <== NOT EXECUTED 10812c: 5e pop %esi <== NOT EXECUTED 10812d: 5f pop %edi <== NOT EXECUTED 10812e: c9 leave <== NOT EXECUTED 10812f: c3 ret <== NOT EXECUTED } if (newTail == tty->rawOutBuf.Head) { /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; 108130: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx) <== NOT EXECUTED 108137: 00 00 00 <== NOT EXECUTED nToSend = 0; /* * check to see if snd wakeup callback was set */ if ( tty->tty_snd.sw_pfn != NULL) { 10813a: 8b 93 d4 00 00 00 mov 0xd4(%ebx),%edx <== NOT EXECUTED 108140: 85 d2 test %edx,%edx <== NOT EXECUTED 108142: 74 3a je 10817e <== NOT EXECUTED (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg); 108144: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 108147: ff b3 d8 00 00 00 pushl 0xd8(%ebx) <== NOT EXECUTED 10814d: 8d 43 30 lea 0x30(%ebx),%eax <== NOT EXECUTED 108150: 50 push %eax <== NOT EXECUTED 108151: ff d2 call *%edx <== NOT EXECUTED 108153: 31 f6 xor %esi,%esi <== NOT EXECUTED 108155: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108158: e9 5d ff ff ff jmp 1080ba <== NOT EXECUTED 10815d: 8d 76 00 lea 0x0(%esi),%esi <== 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); 108160: 9c pushf <== NOT EXECUTED 108161: fa cli <== NOT EXECUTED 108162: 5a pop %edx <== NOT EXECUTED tty->flow_ctrl |= FL_OSTOP; 108163: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108169: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 10816c: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ 108172: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED 108179: 00 00 00 <== NOT EXECUTED rtems_interrupt_enable(level); 10817c: 52 push %edx <== NOT EXECUTED 10817d: 9d popf <== NOT EXECUTED 10817e: 31 f6 xor %esi,%esi <== NOT EXECUTED 108180: e9 35 ff ff ff jmp 1080ba <== NOT EXECUTED 108185: 8d 76 00 lea 0x0(%esi),%esi <== 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, 108188: 52 push %edx <== NOT EXECUTED 108189: 6a 01 push $0x1 <== NOT EXECUTED 10818b: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED 10818e: 50 push %eax <== NOT EXECUTED 10818f: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108192: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTART]), 1); rtems_interrupt_disable(level); 108198: 9c pushf <== NOT EXECUTED 108199: fa cli <== NOT EXECUTED 10819a: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 10819b: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 1081a1: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1081a7: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 1081aa: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 1081b0: 52 push %edx <== NOT EXECUTED 1081b1: 9d popf <== NOT EXECUTED 1081b2: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 1081b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 1081ba: 89 f0 mov %esi,%eax <== NOT EXECUTED 1081bc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1081bf: 5b pop %ebx <== NOT EXECUTED 1081c0: 5e pop %esi <== NOT EXECUTED 1081c1: 5f pop %edi <== NOT EXECUTED 1081c2: c9 leave <== NOT EXECUTED 1081c3: c3 ret <== NOT EXECUTED tty->rawOutBuf.Tail = newTail; if (tty->rawOutBufState == rob_wait) { /* * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 1081c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1081c7: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED 1081cd: e8 d2 22 00 00 call 10a4a4 <== NOT EXECUTED 1081d2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1081d5: e9 7c fe ff ff jmp 108056 <== NOT EXECUTED 1081da: 66 90 xchg %ax,%ax <== NOT EXECUTED */ if (tty->rawOutBufState == rob_wait) { /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 1081dc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1081df: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED 1081e5: e8 ba 22 00 00 call 10a4a4 <== NOT EXECUTED 1081ea: 31 f6 xor %esi,%esi <== NOT EXECUTED 1081ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1081ef: e9 e7 fe ff ff jmp 1080db <== NOT EXECUTED 00109a60 : /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) { 109a60: 55 push %ebp <== NOT EXECUTED 109a61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a63: 57 push %edi <== NOT EXECUTED 109a64: 56 push %esi <== NOT EXECUTED 109a65: 53 push %ebx <== NOT EXECUTED 109a66: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 109a69: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 109a6c: 8d 75 ec lea -0x14(%ebp),%esi <== NOT EXECUTED 109a6f: 8d 7d f3 lea -0xd(%ebp),%edi <== NOT EXECUTED 109a72: 66 90 xchg %ax,%ax <== NOT EXECUTED char c_buf; while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_RX_PROC_EVENT | 109a74: 56 push %esi <== NOT EXECUTED 109a75: 6a 00 push $0x0 <== NOT EXECUTED 109a77: 6a 02 push $0x2 <== NOT EXECUTED 109a79: 6a 03 push $0x3 <== NOT EXECUTED 109a7b: e8 74 02 00 00 call 109cf4 <== NOT EXECUTED TERMIOS_RX_TERMINATE_EVENT), RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &the_event); if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) { 109a80: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a83: f6 45 ec 01 testb $0x1,-0x14(%ebp) <== NOT EXECUTED 109a87: 75 27 jne 109ab0 <== NOT EXECUTED } else { /* * do something */ c = tty->device.pollRead(tty->minor); 109a89: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109a8c: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109a8f: ff 93 a0 00 00 00 call *0xa0(%ebx) <== NOT EXECUTED if (c != EOF) { 109a95: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a98: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 109a9b: 74 d7 je 109a74 <== NOT EXECUTED /* * pollRead did call enqueue on its own */ c_buf = c; 109a9d: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED rtems_termios_enqueue_raw_characters ( 109aa0: 50 push %eax <== NOT EXECUTED 109aa1: 6a 01 push $0x1 <== NOT EXECUTED 109aa3: 57 push %edi <== NOT EXECUTED 109aa4: 53 push %ebx <== NOT EXECUTED 109aa5: e8 b2 e7 ff ff call 10825c <== NOT EXECUTED 109aaa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109aad: eb c5 jmp 109a74 <== NOT EXECUTED 109aaf: 90 nop <== NOT EXECUTED TERMIOS_RX_TERMINATE_EVENT), RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &the_event); if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) { tty->rxTaskId = 0; 109ab0: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED 109ab7: 00 00 00 <== NOT EXECUTED rtems_task_delete(RTEMS_SELF); 109aba: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109abd: 6a 00 push $0x0 <== NOT EXECUTED 109abf: e8 d4 0b 00 00 call 10a698 <== NOT EXECUTED 109ac4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ac7: eb ab jmp 109a74 <== NOT EXECUTED 00107fb4 : * signal receive interrupt to rx daemon * NOTE: This routine runs in the context of the * device receive interrupt handler. */ void rtems_termios_rxirq_occured(struct rtems_termios_tty *tty) { 107fb4: 55 push %ebp <== NOT EXECUTED 107fb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107fb7: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED /* * send event to rx daemon task */ rtems_event_send(tty->rxTaskId,TERMIOS_RX_PROC_EVENT); 107fba: 6a 02 push $0x2 <== NOT EXECUTED 107fbc: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 107fbf: ff b0 c4 00 00 00 pushl 0xc4(%eax) <== NOT EXECUTED 107fc5: e8 be 1e 00 00 call 109e88 <== NOT EXECUTED 107fca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 107fcd: c9 leave <== NOT EXECUTED 107fce: c3 ret <== NOT EXECUTED 001099f4 : /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) { 1099f4: 55 push %ebp <== NOT EXECUTED 1099f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1099f7: 56 push %esi <== NOT EXECUTED 1099f8: 53 push %ebx <== NOT EXECUTED 1099f9: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1099fc: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1099ff: 8d 75 f4 lea -0xc(%ebp),%esi <== NOT EXECUTED 109a02: 66 90 xchg %ax,%ax <== NOT EXECUTED while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_TX_START_EVENT | 109a04: 56 push %esi <== NOT EXECUTED 109a05: 6a 00 push $0x0 <== NOT EXECUTED 109a07: 6a 02 push $0x2 <== NOT EXECUTED 109a09: 6a 03 push $0x3 <== NOT EXECUTED 109a0b: e8 e4 02 00 00 call 109cf4 <== NOT EXECUTED TERMIOS_TX_TERMINATE_EVENT), RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &the_event); if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) { 109a10: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a13: f6 45 f4 01 testb $0x1,-0xc(%ebp) <== NOT EXECUTED 109a17: 75 2b jne 109a44 <== NOT EXECUTED } else { /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 109a19: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 109a1f: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 109a22: 8b 80 34 f4 11 00 mov 0x11f434(%eax),%eax <== NOT EXECUTED 109a28: 85 c0 test %eax,%eax <== NOT EXECUTED 109a2a: 74 09 je 109a35 <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_start(tty); 109a2c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109a2f: 53 push %ebx <== NOT EXECUTED 109a30: ff d0 call *%eax <== NOT EXECUTED 109a32: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * try to push further characters to device */ rtems_termios_refill_transmitter(tty); 109a35: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109a38: 53 push %ebx <== NOT EXECUTED 109a39: e8 92 e5 ff ff call 107fd0 <== NOT EXECUTED 109a3e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a41: eb c1 jmp 109a04 <== NOT EXECUTED 109a43: 90 nop <== NOT EXECUTED TERMIOS_TX_TERMINATE_EVENT), RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &the_event); if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) { tty->txTaskId = 0; 109a44: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED 109a4b: 00 00 00 <== NOT EXECUTED rtems_task_delete(RTEMS_SELF); 109a4e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109a51: 6a 00 push $0x0 <== NOT EXECUTED 109a53: e8 40 0c 00 00 call 10a698 <== NOT EXECUTED 109a58: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a5b: eb a7 jmp 109a04 <== NOT EXECUTED 00108b3c : rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) { 108b3c: 55 push %ebp <== NOT EXECUTED 108b3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108b3f: 57 push %edi <== NOT EXECUTED 108b40: 56 push %esi <== NOT EXECUTED 108b41: 53 push %ebx <== NOT EXECUTED 108b42: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 108b45: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 108b48: 8b 02 mov (%edx),%eax <== NOT EXECUTED 108b4a: 8b 70 28 mov 0x28(%eax),%esi <== NOT EXECUTED rtems_status_code sc; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 108b4d: 6a 00 push $0x0 <== NOT EXECUTED 108b4f: 6a 00 push $0x0 <== NOT EXECUTED 108b51: ff 76 18 pushl 0x18(%esi) <== NOT EXECUTED 108b54: e8 53 18 00 00 call 10a3ac <== NOT EXECUTED 108b59: 89 c7 mov %eax,%edi <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 108b5b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108b5e: 85 c0 test %eax,%eax <== NOT EXECUTED 108b60: 75 2a jne 108b8c <== NOT EXECUTED return sc; if (rtems_termios_linesw[tty->t_line].l_write != NULL) { 108b62: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED 108b68: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 108b6b: 8b 80 2c f4 11 00 mov 0x11f42c(%eax),%eax <== NOT EXECUTED 108b71: 85 c0 test %eax,%eax <== NOT EXECUTED 108b73: 74 23 je 108b98 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_write(tty,args); 108b75: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 108b78: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 108b7b: 56 push %esi <== NOT EXECUTED 108b7c: ff d0 call *%eax <== NOT EXECUTED 108b7e: 89 c7 mov %eax,%edi <== NOT EXECUTED rtems_semaphore_release (tty->osem); 108b80: 58 pop %eax <== NOT EXECUTED 108b81: ff 76 18 pushl 0x18(%esi) <== NOT EXECUTED 108b84: e8 1b 19 00 00 call 10a4a4 <== NOT EXECUTED 108b89: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_termios_puts (args->buffer, args->count, tty); args->bytes_moved = args->count; } rtems_semaphore_release (tty->osem); return sc; } 108b8c: 89 f8 mov %edi,%eax <== NOT EXECUTED 108b8e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108b91: 5b pop %ebx <== NOT EXECUTED 108b92: 5e pop %esi <== NOT EXECUTED 108b93: 5f pop %edi <== NOT EXECUTED 108b94: c9 leave <== NOT EXECUTED 108b95: c3 ret <== NOT EXECUTED 108b96: 66 90 xchg %ax,%ax <== NOT EXECUTED if (rtems_termios_linesw[tty->t_line].l_write != NULL) { sc = rtems_termios_linesw[tty->t_line].l_write(tty,args); rtems_semaphore_release (tty->osem); return sc; } if (tty->termios.c_oflag & OPOST) { 108b98: f6 46 34 01 testb $0x1,0x34(%esi) <== NOT EXECUTED 108b9c: 74 52 je 108bf0 <== NOT EXECUTED uint32_t count = args->count; 108b9e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108ba1: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 108ba4: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED char *buffer = args->buffer; 108ba7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 108baa: 8b 52 08 mov 0x8(%edx),%edx <== NOT EXECUTED 108bad: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED while (count--) 108bb0: 85 c0 test %eax,%eax <== NOT EXECUTED 108bb2: 74 1e je 108bd2 <== NOT EXECUTED 108bb4: 31 db xor %ebx,%ebx <== NOT EXECUTED 108bb6: 66 90 xchg %ax,%ax <== NOT EXECUTED oproc (*buffer++, tty); 108bb8: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 108bbb: 0f b6 04 1a movzbl (%edx,%ebx,1),%eax <== NOT EXECUTED 108bbf: 89 f2 mov %esi,%edx <== NOT EXECUTED 108bc1: e8 b6 fa ff ff call 10867c <== NOT EXECUTED 108bc6: 43 inc %ebx <== NOT EXECUTED return sc; } if (tty->termios.c_oflag & OPOST) { uint32_t count = args->count; char *buffer = args->buffer; while (count--) 108bc7: 39 5d ec cmp %ebx,-0x14(%ebp) <== NOT EXECUTED 108bca: 75 ec jne 108bb8 <== NOT EXECUTED 108bcc: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 108bcf: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED oproc (*buffer++, tty); args->bytes_moved = args->count; 108bd2: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 108bd5: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED } else { rtems_termios_puts (args->buffer, args->count, tty); args->bytes_moved = args->count; } rtems_semaphore_release (tty->osem); 108bd8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108bdb: ff 76 18 pushl 0x18(%esi) <== NOT EXECUTED 108bde: e8 c1 18 00 00 call 10a4a4 <== NOT EXECUTED 108be3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return sc; } 108be6: 89 f8 mov %edi,%eax <== NOT EXECUTED 108be8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108beb: 5b pop %ebx <== NOT EXECUTED 108bec: 5e pop %esi <== NOT EXECUTED 108bed: 5f pop %edi <== NOT EXECUTED 108bee: c9 leave <== NOT EXECUTED 108bef: c3 ret <== NOT EXECUTED while (count--) oproc (*buffer++, tty); args->bytes_moved = args->count; } else { rtems_termios_puts (args->buffer, args->count, tty); 108bf0: 50 push %eax <== NOT EXECUTED 108bf1: 56 push %esi <== NOT EXECUTED 108bf2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108bf5: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 108bf8: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 108bfb: e8 4c f9 ff ff call 10854c <== NOT EXECUTED args->bytes_moved = args->count; 108c00: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 108c03: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 108c06: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED 108c09: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108c0c: eb ca jmp 108bd8 <== NOT EXECUTED 00114404 : */ rtems_status_code rtems_timer_cancel( Objects_Id id ) { 114404: 55 push %ebp <== NOT EXECUTED 114405: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114407: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 11440a: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 11440d: 50 push %eax <== NOT EXECUTED 11440e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114411: 68 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 114416: e8 25 28 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 11441b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11441e: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 114421: 85 d2 test %edx,%edx <== NOT EXECUTED 114423: 74 07 je 11442c <== NOT EXECUTED 114425: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11442a: c9 leave <== NOT EXECUTED 11442b: c3 ret <== NOT EXECUTED the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 11442c: 83 78 38 04 cmpl $0x4,0x38(%eax) <== NOT EXECUTED 114430: 74 0f je 114441 <== NOT EXECUTED (void) _Watchdog_Remove( &the_timer->Ticker ); 114432: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114435: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 114438: 50 push %eax <== NOT EXECUTED 114439: e8 3e 44 00 00 call 11887c <_Watchdog_Remove> <== NOT EXECUTED 11443e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 114441: e8 3e 30 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 114446: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114448: c9 leave <== NOT EXECUTED 114449: c3 ret <== NOT EXECUTED 0010b378 : rtems_status_code rtems_timer_create( rtems_name name, Objects_Id *id ) { 10b378: 55 push %ebp <== NOT EXECUTED 10b379: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b37b: 57 push %edi <== NOT EXECUTED 10b37c: 56 push %esi <== NOT EXECUTED 10b37d: 53 push %ebx <== NOT EXECUTED 10b37e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b381: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b384: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 10b387: 85 f6 test %esi,%esi <== NOT EXECUTED 10b389: 74 71 je 10b3fc <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 10b38b: 85 ff test %edi,%edi <== NOT EXECUTED 10b38d: 0f 84 8d 00 00 00 je 10b420 <== NOT EXECUTED 10b393: a1 18 2e 12 00 mov 0x122e18,%eax <== NOT EXECUTED 10b398: 40 inc %eax <== NOT EXECUTED 10b399: a3 18 2e 12 00 mov %eax,0x122e18 <== NOT EXECUTED /* determine if the CPU has a TSC */ #define x86_has_tsc() \ (x86_capability & (1 << 4)) static inline unsigned long long 10b39e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b3a1: 68 a0 34 12 00 push $0x1234a0 <== NOT EXECUTED 10b3a6: e8 51 0f 00 00 call 10c2fc <_Objects_Allocate> <== NOT EXECUTED 10b3ab: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { 10b3ad: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b3b0: 85 c0 test %eax,%eax <== NOT EXECUTED 10b3b2: 74 58 je 10b40c <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_timer->the_class = TIMER_DORMANT; 10b3b4: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax) <== NOT EXECUTED rdtsc(void) { /* Return the value of the on-chip cycle counter. */ unsigned long long result; asm volatile(".byte 0x0F, 0x31" : "=A" (result)); return result; 10b3bb: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED } /* rdtsc */ 10b3c2: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) <== NOT EXECUTED 10b3c9: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED 10b3d0: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) <== NOT EXECUTED 10b3d7: 8b 48 08 mov 0x8(%eax),%ecx <== NOT EXECUTED 10b3da: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10b3dd: a1 bc 34 12 00 mov 0x1234bc,%eax <== NOT EXECUTED 10b3e2: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10b3e5: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Timer_Information, &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; 10b3e8: 89 0f mov %ecx,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10b3ea: e8 45 1c 00 00 call 10d034 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b3ef: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10b3f1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b3f4: 5b pop %ebx <== NOT EXECUTED 10b3f5: 5e pop %esi <== NOT EXECUTED 10b3f6: 5f pop %edi <== NOT EXECUTED 10b3f7: c9 leave <== NOT EXECUTED 10b3f8: c3 ret <== NOT EXECUTED 10b3f9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED Objects_Id *id ) { Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 10b3fc: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b401: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b404: 5b pop %ebx <== NOT EXECUTED 10b405: 5e pop %esi <== NOT EXECUTED 10b406: 5f pop %edi <== NOT EXECUTED 10b407: c9 leave <== NOT EXECUTED 10b408: c3 ret <== NOT EXECUTED 10b409: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { _Thread_Enable_dispatch(); 10b40c: e8 23 1c 00 00 call 10d034 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b411: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b416: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b419: 5b pop %ebx <== NOT EXECUTED 10b41a: 5e pop %esi <== NOT EXECUTED 10b41b: 5f pop %edi <== NOT EXECUTED 10b41c: c9 leave <== NOT EXECUTED 10b41d: c3 ret <== NOT EXECUTED 10b41e: 66 90 xchg %ax,%ax <== NOT EXECUTED Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 10b420: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b425: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b428: 5b pop %ebx <== NOT EXECUTED 10b429: 5e pop %esi <== NOT EXECUTED 10b42a: 5f pop %edi <== NOT EXECUTED 10b42b: c9 leave <== NOT EXECUTED 10b42c: c3 ret <== NOT EXECUTED 00114504 : */ rtems_status_code rtems_timer_delete( Objects_Id id ) { 114504: 55 push %ebp <== NOT EXECUTED 114505: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114507: 53 push %ebx <== NOT EXECUTED 114508: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 11450b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 11450e: 50 push %eax <== NOT EXECUTED 11450f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114512: 68 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 114517: e8 24 27 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED 11451c: 89 c3 mov %eax,%ebx <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 11451e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114521: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 114524: 85 c9 test %ecx,%ecx <== NOT EXECUTED 114526: 75 38 jne 114560 <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Timer_Information, &the_timer->Object ); 114528: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11452b: 50 push %eax <== NOT EXECUTED 11452c: 68 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 114531: e8 56 22 00 00 call 11678c <_Objects_Close> <== NOT EXECUTED (void) _Watchdog_Remove( &the_timer->Ticker ); 114536: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 114539: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 11453c: e8 3b 43 00 00 call 11887c <_Watchdog_Remove> <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for * the heap * @param[in] size is the size in bytes of the memory area for the heap * @param[in] page_size is the size in bytes of the allocation unit * * @return This method returns the maximum memory available. If 114541: 58 pop %eax <== NOT EXECUTED 114542: 5a pop %edx <== NOT EXECUTED 114543: 53 push %ebx <== NOT EXECUTED 114544: 68 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 114549: e8 7e 25 00 00 call 116acc <_Objects_Free> <== NOT EXECUTED _Timer_Free( the_timer ); _Thread_Enable_dispatch(); 11454e: e8 31 2f 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 114553: 31 c0 xor %eax,%eax <== NOT EXECUTED 114555: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114558: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11455b: c9 leave <== NOT EXECUTED 11455c: c3 ret <== NOT EXECUTED 11455d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 114560: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114565: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114568: c9 leave <== NOT EXECUTED 114569: c3 ret <== NOT EXECUTED 0010b430 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 10b430: 55 push %ebp <== NOT EXECUTED 10b431: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b433: 57 push %edi <== NOT EXECUTED 10b434: 56 push %esi <== NOT EXECUTED 10b435: 53 push %ebx <== NOT EXECUTED 10b436: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10b439: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 10b43c: 85 f6 test %esi,%esi <== NOT EXECUTED 10b43e: 0f 84 98 00 00 00 je 10b4dc <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( !routine ) 10b444: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10b447: 85 ff test %edi,%edi <== NOT EXECUTED 10b449: 0f 84 9d 00 00 00 je 10b4ec <== NOT EXECUTED 10b44f: 53 push %ebx <== NOT EXECUTED 10b450: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b453: 50 push %eax <== NOT EXECUTED 10b454: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b457: 68 a0 34 12 00 push $0x1234a0 <== NOT EXECUTED 10b45c: e8 8f 13 00 00 call 10c7f0 <_Objects_Get> <== NOT EXECUTED 10b461: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 10b463: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b466: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10b469: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b46b: 75 5f jne 10b4cc <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 10b46d: 8d 78 10 lea 0x10(%eax),%edi <== NOT EXECUTED 10b470: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b473: 57 push %edi <== NOT EXECUTED 10b474: e8 77 2c 00 00 call 10e0f0 <_Watchdog_Remove> <== NOT EXECUTED _ISR_Disable( level ); 10b479: 9c pushf <== NOT EXECUTED 10b47a: fa cli <== NOT EXECUTED 10b47b: 58 pop %eax <== NOT EXECUTED /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { 10b47c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b47f: 8b 53 18 mov 0x18(%ebx),%edx <== NOT EXECUTED 10b482: 85 d2 test %edx,%edx <== NOT EXECUTED 10b484: 75 76 jne 10b4fc <== NOT EXECUTED /* * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL; 10b486: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) <== NOT EXECUTED rdtsc(void) { /* Return the value of the on-chip cycle counter. */ unsigned long long result; asm volatile(".byte 0x0F, 0x31" : "=A" (result)); return result; 10b48d: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED } /* rdtsc */ 10b494: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10b497: 89 53 2c mov %edx,0x2c(%ebx) <== NOT EXECUTED 10b49a: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b49d: 89 53 30 mov %edx,0x30(%ebx) <== NOT EXECUTED 10b4a0: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10b4a3: 89 53 34 mov %edx,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 10b4a6: 50 push %eax <== NOT EXECUTED 10b4a7: 9d popf <== NOT EXECUTED 10b4a8: 89 73 1c mov %esi,0x1c(%ebx) <== NOT EXECUTED 10b4ab: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b4ae: 57 push %edi <== NOT EXECUTED 10b4af: 68 fc 2e 12 00 push $0x122efc <== NOT EXECUTED 10b4b4: e8 07 2b 00 00 call 10dfc0 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 10b4b9: e8 76 1b 00 00 call 10d034 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b4be: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b4c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b4c3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b4c6: 5b pop %ebx <== NOT EXECUTED 10b4c7: 5e pop %esi <== NOT EXECUTED 10b4c8: 5f pop %edi <== NOT EXECUTED 10b4c9: c9 leave <== NOT EXECUTED 10b4ca: c3 ret <== NOT EXECUTED 10b4cb: 90 nop <== NOT EXECUTED if ( !routine ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 10b4cc: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b4d1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b4d4: 5b pop %ebx <== NOT EXECUTED 10b4d5: 5e pop %esi <== NOT EXECUTED 10b4d6: 5f pop %edi <== NOT EXECUTED 10b4d7: c9 leave <== NOT EXECUTED 10b4d8: c3 ret <== NOT EXECUTED 10b4d9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 10b4dc: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b4e1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b4e4: 5b pop %ebx <== NOT EXECUTED 10b4e5: 5e pop %esi <== NOT EXECUTED 10b4e6: 5f pop %edi <== NOT EXECUTED 10b4e7: c9 leave <== NOT EXECUTED 10b4e8: c3 ret <== NOT EXECUTED 10b4e9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ISR_Level level; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; if ( !routine ) 10b4ec: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b4f1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b4f4: 5b pop %ebx <== NOT EXECUTED 10b4f5: 5e pop %esi <== NOT EXECUTED 10b4f6: 5f pop %edi <== NOT EXECUTED 10b4f7: c9 leave <== NOT EXECUTED 10b4f8: c3 ret <== NOT EXECUTED 10b4f9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 10b4fc: 50 push %eax <== NOT EXECUTED 10b4fd: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); 10b4fe: e8 31 1b 00 00 call 10d034 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b503: 31 c0 xor %eax,%eax 10b505: eb ca jmp 10b4d1 <== NOT EXECUTED 00114644 : Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 114644: 55 push %ebp <== NOT EXECUTED 114645: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114647: 57 push %edi <== NOT EXECUTED 114648: 56 push %esi <== NOT EXECUTED 114649: 53 push %ebx <== NOT EXECUTED 11464a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) 11464d: 80 3d 8c 6d 13 00 00 cmpb $0x0,0x136d8c <== NOT EXECUTED 114654: 75 0e jne 114664 <== NOT EXECUTED 114656: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11465b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11465e: 5b pop %ebx <== NOT EXECUTED 11465f: 5e pop %esi <== NOT EXECUTED 114660: 5f pop %edi <== NOT EXECUTED 114661: c9 leave <== NOT EXECUTED 114662: c3 ret <== NOT EXECUTED 114663: 90 nop <== NOT EXECUTED rtems_interval seconds; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) 114664: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114667: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11466a: e8 d1 d6 ff ff call 111d40 <_TOD_Validate> <== NOT EXECUTED 11466f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114672: 84 c0 test %al,%al <== NOT EXECUTED 114674: 74 23 je 114699 <== NOT EXECUTED return RTEMS_INVALID_CLOCK; if ( !routine ) 114676: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 114679: 85 f6 test %esi,%esi <== NOT EXECUTED 11467b: 0f 84 a3 00 00 00 je 114724 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); 114681: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114684: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 114687: e8 24 d6 ff ff call 111cb0 <_TOD_To_seconds> <== NOT EXECUTED 11468c: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( seconds <= _TOD_Seconds_since_epoch ) 11468e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114691: 3b 05 0c 6e 13 00 cmp 0x136e0c,%eax <== NOT EXECUTED 114697: 77 0f ja 1146a8 <== NOT EXECUTED _Watchdog_Insert_seconds( &the_timer->Ticker, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 114699: b8 14 00 00 00 mov $0x14,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11469e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1146a1: 5b pop %ebx <== NOT EXECUTED 1146a2: 5e pop %esi <== NOT EXECUTED 1146a3: 5f pop %edi <== NOT EXECUTED 1146a4: c9 leave <== NOT EXECUTED 1146a5: c3 ret <== NOT EXECUTED 1146a6: 66 90 xchg %ax,%ax <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 1146a8: 53 push %ebx <== NOT EXECUTED 1146a9: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1146ac: 50 push %eax <== NOT EXECUTED 1146ad: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1146b0: 68 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 1146b5: e8 86 25 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED 1146ba: 89 c6 mov %eax,%esi <== NOT EXECUTED seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 1146bc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1146bf: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 1146c2: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1146c4: 75 52 jne 114718 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 1146c6: 8d 58 10 lea 0x10(%eax),%ebx <== NOT EXECUTED 1146c9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1146cc: 53 push %ebx <== NOT EXECUTED 1146cd: e8 aa 41 00 00 call 11887c <_Watchdog_Remove> <== NOT EXECUTED the_timer->the_class = TIMER_TIME_OF_DAY; 1146d2: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 1146d9: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 1146e0: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1146e3: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 1146e6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1146e9: 89 46 30 mov %eax,0x30(%esi) <== NOT EXECUTED * the heap 1146ec: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1146ef: 89 46 34 mov %eax,0x34(%esi) <== NOT EXECUTED * @return TRUE if successfully able to resize the block. * FALSE if the block can't be resized in place. */ bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, 1146f2: 2b 3d 0c 6e 13 00 sub 0x136e0c,%edi <== NOT EXECUTED 1146f8: 89 7e 1c mov %edi,0x1c(%esi) <== NOT EXECUTED size_t size ); 1146fb: 58 pop %eax <== NOT EXECUTED 1146fc: 5a pop %edx <== NOT EXECUTED 1146fd: 53 push %ebx <== NOT EXECUTED 1146fe: 68 50 6e 13 00 push $0x136e50 <== NOT EXECUTED 114703: e8 44 40 00 00 call 11874c <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _Watchdog_Insert_seconds( &the_timer->Ticker, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); 114708: e8 77 2d 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 11470d: 31 c0 xor %eax,%eax <== NOT EXECUTED 11470f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114712: e9 44 ff ff ff jmp 11465b <== NOT EXECUTED 114717: 90 nop <== NOT EXECUTED seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 114718: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 11471d: e9 39 ff ff ff jmp 11465b <== NOT EXECUTED 114722: 66 90 xchg %ax,%ax <== NOT EXECUTED return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; if ( !routine ) 114724: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 114729: e9 2d ff ff ff jmp 11465b <== NOT EXECUTED 00114730 : rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) { 114730: 55 push %ebp <== NOT EXECUTED 114731: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114733: 53 push %ebx <== NOT EXECUTED 114734: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 114737: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 11473a: 85 db test %ebx,%ebx <== NOT EXECUTED 11473c: 74 4e je 11478c <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 11473e: 52 push %edx <== NOT EXECUTED 11473f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 114742: 50 push %eax <== NOT EXECUTED 114743: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114746: 68 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 11474b: e8 f0 24 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED 114750: 89 c2 mov %eax,%edx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 114752: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114755: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 114758: 85 c0 test %eax,%eax <== NOT EXECUTED 11475a: 74 0c je 114768 <== NOT EXECUTED 11475c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114761: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114764: c9 leave <== NOT EXECUTED 114765: c3 ret <== NOT EXECUTED 114766: 66 90 xchg %ax,%ax <== NOT EXECUTED the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 114768: 8b 42 38 mov 0x38(%edx),%eax <== NOT EXECUTED 11476b: 89 03 mov %eax,(%ebx) <== NOT EXECUTED the_info->initial = the_timer->Ticker.initial; 11476d: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 114770: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED the_info->start_time = the_timer->Ticker.start_time; 114773: 8b 42 24 mov 0x24(%edx),%eax <== NOT EXECUTED 114776: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED the_info->stop_time = the_timer->Ticker.stop_time; 114779: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 11477c: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 11477f: e8 00 2d 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 114784: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114786: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114789: c9 leave <== NOT EXECUTED 11478a: c3 ret <== NOT EXECUTED 11478b: 90 nop <== NOT EXECUTED ) { Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 11478c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114791: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114794: c9 leave <== NOT EXECUTED 114795: c3 ret <== NOT EXECUTED 00114798 : rtems_status_code rtems_timer_ident( rtems_name name, Objects_Id *id ) { 114798: 55 push %ebp <== NOT EXECUTED 114799: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11479b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 11479e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1147a1: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 1147a6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1147a9: 68 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 1147ae: e8 e5 25 00 00 call 116d98 <_Objects_Name_to_id_u32> <== NOT EXECUTED 1147b3: 8b 04 85 74 b7 12 00 mov 0x12b774(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 1147ba: c9 leave <== NOT EXECUTED 1147bb: c3 ret <== NOT EXECUTED 00114a40 : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 114a40: 55 push %ebp <== NOT EXECUTED 114a41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114a43: 56 push %esi <== NOT EXECUTED 114a44: 53 push %ebx <== NOT EXECUTED 114a45: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 114a48: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ); 114a4b: 85 d2 test %edx,%edx <== NOT EXECUTED 114a4d: 75 0d jne 114a5c <== NOT EXECUTED * but there is actually no way (in normal circumstances) that the * start can fail. The id and starting address are known to be * be good. If this service fails, something is weirdly wrong on the * target such as a stray write in an ISR or incorrect memory layout. */ initialized = false; 114a4f: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED } return status; } 114a54: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 114a57: 5b pop %ebx <== NOT EXECUTED 114a58: 5e pop %esi <== NOT EXECUTED 114a59: c9 leave <== NOT EXECUTED 114a5a: c3 ret <== NOT EXECUTED 114a5b: 90 nop <== NOT EXECUTED 114a5c: 0f b6 05 b4 e3 12 00 movzbl 0x12e3b4,%eax <== NOT EXECUTED 114a63: 39 c2 cmp %eax,%edx <== NOT EXECUTED 114a65: 77 31 ja 114a98 <== NOT EXECUTED 114a67: 89 d6 mov %edx,%esi <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 114a69: a1 78 6d 13 00 mov 0x136d78,%eax <== NOT EXECUTED 114a6e: 40 inc %eax <== NOT EXECUTED 114a6f: a3 78 6d 13 00 mov %eax,0x136d78 <== NOT EXECUTED /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 114a74: 8a 1d 40 27 13 00 mov 0x132740,%bl <== NOT EXECUTED initialized = true; 114a7a: c6 05 40 27 13 00 01 movb $0x1,0x132740 <== NOT EXECUTED _Thread_Enable_dispatch(); 114a81: e8 fe 29 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( tmpInitialized ) 114a86: 84 db test %bl,%bl <== NOT EXECUTED 114a88: 74 16 je 114aa0 <== NOT EXECUTED 114a8a: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED */ initialized = false; } return status; } 114a8f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 114a92: 5b pop %ebx <== NOT EXECUTED 114a93: 5e pop %esi <== NOT EXECUTED 114a94: c9 leave <== NOT EXECUTED 114a95: c3 ret <== NOT EXECUTED 114a96: 66 90 xchg %ax,%ax <== NOT EXECUTED * structured so we check it is invalid before looking for * a specific invalid value as the default. */ _priority = priority; if ( !_RTEMS_tasks_Priority_is_valid( priority ) ) { if ( priority != RTEMS_TIMER_SERVER_DEFAULT_PRIORITY ) 114a98: 42 inc %edx <== NOT EXECUTED 114a99: 75 b4 jne 114a4f <== NOT EXECUTED 114a9b: 31 f6 xor %esi,%esi <== NOT EXECUTED 114a9d: eb ca jmp 114a69 <== NOT EXECUTED 114a9f: 90 nop <== NOT EXECUTED 114aa0: c7 05 e0 6c 13 00 e4 movl $0x136ce4,0x136ce0 <== NOT EXECUTED 114aa7: 6c 13 00 <== NOT EXECUTED 114aaa: c7 05 e4 6c 13 00 00 movl $0x0,0x136ce4 <== NOT EXECUTED 114ab1: 00 00 00 <== NOT EXECUTED 114ab4: c7 05 e8 6c 13 00 e0 movl $0x136ce0,0x136ce8 <== NOT EXECUTED 114abb: 6c 13 00 <== NOT EXECUTED * other library rules. For example, if using a TSR written in Ada the * Server should run at the same priority as the priority Ada task. * Otherwise, the priority ceiling for the mutex used to protect the * GNAT run-time is violated. */ status = rtems_task_create( 114abe: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114ac1: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 114ac4: 50 push %eax <== NOT EXECUTED 114ac5: 81 4d 10 00 80 00 00 orl $0x8000,0x10(%ebp) <== NOT EXECUTED 114acc: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 114acf: 68 00 01 00 00 push $0x100 <== NOT EXECUTED 114ad4: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 114ad7: 56 push %esi <== NOT EXECUTED 114ad8: 68 45 4d 49 54 push $0x54494d45 <== NOT EXECUTED 114add: e8 fa f1 ff ff call 113cdc <== NOT EXECUTED /* user may want floating point but we need */ /* system task specified for 0 priority */ attribute_set | RTEMS_SYSTEM_TASK, &id /* get the id back */ ); if (status) { 114ae2: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 114ae5: 85 c0 test %eax,%eax <== NOT EXECUTED 114ae7: 0f 85 b2 00 00 00 jne 114b9f <== NOT EXECUTED * to a TCB pointer from here out. * * NOTE: Setting the pointer to the Timer Server TCB to a value other than * NULL indicates that task-based timer support is initialized. */ _Timer_Server = (Thread_Control *)_Objects_Get_local_object( 114aed: 8b 4d f4 mov -0xc(%ebp),%ecx <== NOT EXECUTED bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 114af0: 66 3b 0d 90 6c 13 00 cmp 0x136c90,%cx <== NOT EXECUTED 114af7: 0f 86 b3 00 00 00 jbe 114bb0 <== NOT EXECUTED 114afd: 31 c0 xor %eax,%eax <== NOT EXECUTED 114aff: a3 e4 77 13 00 mov %eax,0x1377e4 <== NOT EXECUTED 114b04: c7 05 c0 6c 13 00 c4 movl $0x136cc4,0x136cc0 <== NOT EXECUTED 114b0b: 6c 13 00 <== NOT EXECUTED 114b0e: c7 05 c4 6c 13 00 00 movl $0x0,0x136cc4 <== NOT EXECUTED 114b15: 00 00 00 <== NOT EXECUTED 114b18: c7 05 c8 6c 13 00 c0 movl $0x136cc0,0x136cc8 <== NOT EXECUTED 114b1f: 6c 13 00 <== NOT EXECUTED 114b22: c7 05 d4 6c 13 00 d8 movl $0x136cd8,0x136cd4 <== NOT EXECUTED 114b29: 6c 13 00 <== NOT EXECUTED 114b2c: c7 05 d8 6c 13 00 00 movl $0x0,0x136cd8 <== NOT EXECUTED 114b33: 00 00 00 <== NOT EXECUTED 114b36: c7 05 dc 6c 13 00 d4 movl $0x136cd4,0x136cdc <== NOT EXECUTED 114b3d: 6c 13 00 <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 114b40: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 114b47: c7 40 64 ec 72 11 00 movl $0x1172ec,0x64(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 114b4e: 89 48 68 mov %ecx,0x68(%eax) <== NOT EXECUTED * the heap 114b51: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 114b58: c7 05 08 6d 13 00 00 movl $0x0,0x136d08 <== NOT EXECUTED 114b5f: 00 00 00 <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 114b62: c7 05 1c 6d 13 00 ec movl $0x1172ec,0x136d1c <== NOT EXECUTED 114b69: 72 11 00 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 114b6c: 89 0d 20 6d 13 00 mov %ecx,0x136d20 <== NOT EXECUTED * the heap 114b72: c7 05 24 6d 13 00 00 movl $0x0,0x136d24 <== NOT EXECUTED 114b79: 00 00 00 <== NOT EXECUTED /* * Initialize the pointer to the timer reset method so applications * that do not use the Timer Server do not have to pull it in. */ _Timer_Server_schedule_operation = _Timer_Server_schedule_operation_method; 114b7c: c7 05 e0 77 13 00 c0 movl $0x114bc0,0x1377e0 <== NOT EXECUTED 114b83: 4b 11 00 <== NOT EXECUTED /* * Start the timer server */ status = rtems_task_start( 114b86: 50 push %eax <== NOT EXECUTED 114b87: 6a 00 push $0x0 <== NOT EXECUTED 114b89: 68 5c 4c 11 00 push $0x114c5c <== NOT EXECUTED 114b8e: 51 push %ecx <== NOT EXECUTED 114b8f: e8 5c f6 ff ff call 1141f0 <== NOT EXECUTED id, /* the id from create */ (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */ 0 /* there is no argument */ ); if (status) { 114b94: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114b97: 85 c0 test %eax,%eax <== NOT EXECUTED 114b99: 0f 84 b5 fe ff ff je 114a54 <== NOT EXECUTED * but there is actually no way (in normal circumstances) that the * start can fail. The id and starting address are known to be * be good. If this service fails, something is weirdly wrong on the * target such as a stray write in an ISR or incorrect memory layout. */ initialized = false; 114b9f: c6 05 40 27 13 00 00 movb $0x0,0x132740 <== NOT EXECUTED } return status; } 114ba6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 114ba9: 5b pop %ebx <== NOT EXECUTED 114baa: 5e pop %esi <== NOT EXECUTED 114bab: c9 leave <== NOT EXECUTED 114bac: c3 ret <== NOT EXECUTED 114bad: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 114bb0: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 114bb3: a1 9c 6c 13 00 mov 0x136c9c,%eax <== NOT EXECUTED 114bb8: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED 114bbb: e9 3f ff ff ff jmp 114aff <== NOT EXECUTED 001147bc : */ rtems_status_code rtems_timer_reset( Objects_Id id ) { 1147bc: 55 push %ebp <== NOT EXECUTED 1147bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1147bf: 53 push %ebx <== NOT EXECUTED 1147c0: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 1147c3: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1147c6: 50 push %eax <== NOT EXECUTED 1147c7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1147ca: 68 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 1147cf: e8 6c 24 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED 1147d4: 89 c3 mov %eax,%ebx <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 1147d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1147d9: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 1147dc: 85 c0 test %eax,%eax <== NOT EXECUTED 1147de: 74 0c je 1147ec <== NOT EXECUTED 1147e0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1147e5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1147e8: c9 leave <== NOT EXECUTED 1147e9: c3 ret <== NOT EXECUTED 1147ea: 66 90 xchg %ax,%ax <== NOT EXECUTED the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: switch ( the_timer->the_class ) { 1147ec: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 1147ef: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 1147f2: 74 40 je 114834 <== NOT EXECUTED 1147f4: 73 2a jae 114820 <== NOT EXECUTED case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); 1147f6: 83 c3 10 add $0x10,%ebx <== NOT EXECUTED 1147f9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1147fc: 53 push %ebx <== NOT EXECUTED 1147fd: e8 7a 40 00 00 call 11887c <_Watchdog_Remove> <== NOT EXECUTED _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 114802: 5a pop %edx <== NOT EXECUTED 114803: 59 pop %ecx <== NOT EXECUTED 114804: 53 push %ebx <== NOT EXECUTED 114805: 68 5c 6e 13 00 push $0x136e5c <== NOT EXECUTED 11480a: e8 3d 3f 00 00 call 11874c <_Watchdog_Insert> <== NOT EXECUTED 11480f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case TIMER_TIME_OF_DAY_ON_TASK: case TIMER_DORMANT: _Thread_Enable_dispatch(); return RTEMS_NOT_DEFINED; } _Thread_Enable_dispatch(); 114812: e8 6d 2c 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 114817: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114819: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11481c: c9 leave <== NOT EXECUTED 11481d: c3 ret <== NOT EXECUTED 11481e: 66 90 xchg %ax,%ax <== NOT EXECUTED the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: switch ( the_timer->the_class ) { 114820: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 114823: 77 ed ja 114812 <== NOT EXECUTED (*_Timer_Server_schedule_operation)( the_timer ); break; case TIMER_TIME_OF_DAY: case TIMER_TIME_OF_DAY_ON_TASK: case TIMER_DORMANT: _Thread_Enable_dispatch(); 114825: e8 5a 2c 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 11482a: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11482f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114832: c9 leave <== NOT EXECUTED 114833: c3 ret <== NOT EXECUTED case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); break; case TIMER_INTERVAL_ON_TASK: if ( !_Timer_Server_schedule_operation ) { 114834: a1 e0 77 13 00 mov 0x1377e0,%eax <== NOT EXECUTED 114839: 85 c0 test %eax,%eax <== NOT EXECUTED 11483b: 74 1b je 114858 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } _Watchdog_Remove( &the_timer->Ticker ); 11483d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114840: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 114843: 50 push %eax <== NOT EXECUTED 114844: e8 33 40 00 00 call 11887c <_Watchdog_Remove> <== NOT EXECUTED (*_Timer_Server_schedule_operation)( the_timer ); 114849: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 11484c: ff 15 e0 77 13 00 call *0x1377e0 <== NOT EXECUTED 114852: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114855: eb bb jmp 114812 <== NOT EXECUTED 114857: 90 nop <== NOT EXECUTED _Watchdog_Remove( &the_timer->Ticker ); _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); break; case TIMER_INTERVAL_ON_TASK: if ( !_Timer_Server_schedule_operation ) { _Thread_Enable_dispatch(); 114858: e8 27 2c 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 11485d: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 114862: eb 81 jmp 1147e5 <== NOT EXECUTED 00114864 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 114864: 55 push %ebp <== NOT EXECUTED 114865: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114867: 53 push %ebx <== NOT EXECUTED 114868: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 11486b: a1 e4 77 13 00 mov 0x1377e4,%eax <== NOT EXECUTED 114870: 85 c0 test %eax,%eax <== NOT EXECUTED 114872: 0f 84 b0 00 00 00 je 114928 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !routine ) 114878: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11487b: 85 c0 test %eax,%eax <== NOT EXECUTED 11487d: 0f 84 b1 00 00 00 je 114934 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 114883: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 114886: 85 c0 test %eax,%eax <== NOT EXECUTED 114888: 75 0a jne 114894 <== NOT EXECUTED 11488a: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11488f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114892: c9 leave <== NOT EXECUTED 114893: c3 ret <== NOT EXECUTED 114894: 53 push %ebx <== NOT EXECUTED 114895: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 114898: 50 push %eax <== NOT EXECUTED 114899: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11489c: 68 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 1148a1: e8 9a 23 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED 1148a6: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 1148a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1148ab: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 1148ae: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1148b0: 75 5a jne 11490c <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 1148b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1148b5: 8d 40 10 lea 0x10(%eax),%eax <== NOT EXECUTED 1148b8: 50 push %eax <== NOT EXECUTED 1148b9: e8 be 3f 00 00 call 11887c <_Watchdog_Remove> <== NOT EXECUTED _ISR_Disable( level ); 1148be: 9c pushf <== NOT EXECUTED 1148bf: fa cli <== NOT EXECUTED 1148c0: 58 pop %eax <== NOT EXECUTED /* * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { 1148c1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1148c4: 8b 53 18 mov 0x18(%ebx),%edx <== NOT EXECUTED 1148c7: 85 d2 test %edx,%edx <== NOT EXECUTED 1148c9: 75 4d jne 114918 <== NOT EXECUTED /* * OK. Now we now the timer was not rescheduled by an interrupt * so we can atomically initialize it as in use. */ the_timer->the_class = TIMER_INTERVAL_ON_TASK; 1148cb: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 1148d2: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 1148d9: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 1148dc: 89 53 2c mov %edx,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 1148df: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1148e2: 89 53 30 mov %edx,0x30(%ebx) <== NOT EXECUTED * the heap 1148e5: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 1148e8: 89 53 34 mov %edx,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; 1148eb: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 1148ee: 89 53 1c mov %edx,0x1c(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 1148f1: 50 push %eax <== NOT EXECUTED 1148f2: 9d popf <== NOT EXECUTED /* * _Timer_Server_schedule_operation != NULL because we checked that * _Timer_Server was != NULL above. Both are set at the same time. */ (*_Timer_Server_schedule_operation)( the_timer ); 1148f3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1148f6: 53 push %ebx <== NOT EXECUTED 1148f7: ff 15 e0 77 13 00 call *0x1377e0 <== NOT EXECUTED _Thread_Enable_dispatch(); 1148fd: e8 82 2b 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 114902: 31 c0 xor %eax,%eax <== NOT EXECUTED 114904: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114907: eb 86 jmp 11488f <== NOT EXECUTED 114909: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 11490c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114911: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114914: c9 leave <== NOT EXECUTED 114915: c3 ret <== NOT EXECUTED 114916: 66 90 xchg %ax,%ax <== NOT EXECUTED * Check to see if the watchdog has just been inserted by a * higher priority interrupt. If so, abandon this insert. */ if ( the_timer->Ticker.state != WATCHDOG_INACTIVE ) { _ISR_Enable( level ); 114918: 50 push %eax <== NOT EXECUTED 114919: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); 11491a: e8 65 2b 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 11491f: 31 c0 xor %eax,%eax <== NOT EXECUTED 114921: e9 69 ff ff ff jmp 11488f <== NOT EXECUTED 114926: 66 90 xchg %ax,%ax <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 114928: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 11492d: e9 5d ff ff ff jmp 11488f <== NOT EXECUTED 114932: 66 90 xchg %ax,%ax <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !routine ) 114934: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 114939: e9 51 ff ff ff jmp 11488f <== NOT EXECUTED 00114940 : Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 114940: 55 push %ebp <== NOT EXECUTED 114941: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114943: 56 push %esi <== NOT EXECUTED 114944: 53 push %ebx <== NOT EXECUTED 114945: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_Timer_Server ) 114948: 8b 1d e4 77 13 00 mov 0x1377e4,%ebx <== NOT EXECUTED 11494e: 85 db test %ebx,%ebx <== NOT EXECUTED 114950: 0f 84 d2 00 00 00 je 114a28 <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 114956: 80 3d 8c 6d 13 00 00 cmpb $0x0,0x136d8c <== NOT EXECUTED 11495d: 0f 84 ad 00 00 00 je 114a10 <== NOT EXECUTED return RTEMS_NOT_DEFINED; if ( !routine ) 114963: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 114966: 85 c9 test %ecx,%ecx <== NOT EXECUTED 114968: 0f 84 ae 00 00 00 je 114a1c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 11496e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114971: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 114974: e8 c7 d3 ff ff call 111d40 <_TOD_Validate> <== NOT EXECUTED 114979: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11497c: 84 c0 test %al,%al <== NOT EXECUTED 11497e: 75 0c jne 11498c <== NOT EXECUTED */ (*_Timer_Server_schedule_operation)( the_timer ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 114980: b8 14 00 00 00 mov $0x14,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114985: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 114988: 5b pop %ebx <== NOT EXECUTED 114989: 5e pop %esi <== NOT EXECUTED 11498a: c9 leave <== NOT EXECUTED 11498b: c3 ret <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 11498c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11498f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 114992: e8 19 d3 ff ff call 111cb0 <_TOD_To_seconds> <== NOT EXECUTED 114997: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( seconds <= _TOD_Seconds_since_epoch ) 114999: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11499c: 3b 05 0c 6e 13 00 cmp 0x136e0c,%eax <== NOT EXECUTED 1149a2: 76 dc jbe 114980 <== NOT EXECUTED /** * This routine grows @a the_heap memory area using the size bytes which * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 1149a4: 52 push %edx <== NOT EXECUTED 1149a5: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1149a8: 50 push %eax <== NOT EXECUTED 1149a9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1149ac: 68 a0 77 13 00 push $0x1377a0 <== NOT EXECUTED 1149b1: e8 8a 22 00 00 call 116c40 <_Objects_Get> <== NOT EXECUTED 1149b6: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 1149b8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1149bb: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 1149be: 85 c0 test %eax,%eax <== NOT EXECUTED 1149c0: 75 72 jne 114a34 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 1149c2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1149c5: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 1149c8: 50 push %eax <== NOT EXECUTED 1149c9: e8 ae 3e 00 00 call 11887c <_Watchdog_Remove> <== NOT EXECUTED the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 1149ce: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 1149d5: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 1149dc: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1149df: 89 43 2c mov %eax,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 1149e2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1149e5: 89 43 30 mov %eax,0x30(%ebx) <== NOT EXECUTED * the heap 1149e8: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1149eb: 89 43 34 mov %eax,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch; 1149ee: 2b 35 0c 6e 13 00 sub 0x136e0c,%esi <== NOT EXECUTED 1149f4: 89 73 1c mov %esi,0x1c(%ebx) <== NOT EXECUTED /* * _Timer_Server_schedule_operation != NULL because we checked that * _Timer_Server was != NULL above. Both are set at the same time. */ (*_Timer_Server_schedule_operation)( the_timer ); 1149f7: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1149fa: ff 15 e0 77 13 00 call *0x1377e0 <== NOT EXECUTED _Thread_Enable_dispatch(); 114a00: e8 7f 2a 00 00 call 117484 <_Thread_Enable_dispatch> <== NOT EXECUTED 114a05: 31 c0 xor %eax,%eax <== NOT EXECUTED 114a07: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114a0a: e9 76 ff ff ff jmp 114985 <== NOT EXECUTED 114a0f: 90 nop <== NOT EXECUTED rtems_interval seconds; if ( !_Timer_Server ) return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 114a10: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114a15: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 114a18: 5b pop %ebx <== NOT EXECUTED 114a19: 5e pop %esi <== NOT EXECUTED 114a1a: c9 leave <== NOT EXECUTED 114a1b: c3 ret <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) 114a1c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 114a21: e9 5f ff ff ff jmp 114985 <== NOT EXECUTED 114a26: 66 90 xchg %ax,%ax <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_Timer_Server ) 114a28: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 114a2d: e9 53 ff ff ff jmp 114985 <== NOT EXECUTED 114a32: 66 90 xchg %ax,%ax <== NOT EXECUTED seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 114a34: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 114a39: e9 47 ff ff ff jmp 114985 <== NOT EXECUTED 0010b6d0 : static int rtems_verror( uint32_t error_flag, const char *printf_format, va_list arglist ) { 10b6d0: 55 push %ebp <== NOT EXECUTED 10b6d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b6d3: 57 push %edi <== NOT EXECUTED 10b6d4: 56 push %esi <== NOT EXECUTED 10b6d5: 53 push %ebx <== NOT EXECUTED 10b6d6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b6d9: 89 c6 mov %eax,%esi <== NOT EXECUTED 10b6db: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 10b6de: 89 cf mov %ecx,%edi <== NOT EXECUTED int local_errno = 0; int chars_written = 0; rtems_status_code status; if (error_flag & RTEMS_ERROR_PANIC) 10b6e0: 25 00 00 00 20 and $0x20000000,%eax <== NOT EXECUTED 10b6e5: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 10b6e8: 74 2a je 10b714 <== NOT EXECUTED { if (rtems_panic_in_progress++) 10b6ea: 8b 15 30 db 12 00 mov 0x12db30,%edx <== NOT EXECUTED 10b6f0: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10b6f3: a3 30 db 12 00 mov %eax,0x12db30 <== NOT EXECUTED 10b6f8: 85 d2 test %edx,%edx <== NOT EXECUTED 10b6fa: 74 0b je 10b707 <== NOT EXECUTED 10b6fc: a1 b8 dc 12 00 mov 0x12dcb8,%eax <== NOT EXECUTED 10b701: 40 inc %eax <== NOT EXECUTED 10b702: a3 b8 dc 12 00 mov %eax,0x12dcb8 <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) 10b707: 83 3d 30 db 12 00 02 cmpl $0x2,0x12db30 <== NOT EXECUTED 10b70e: 0f 8f dc 00 00 00 jg 10b7f0 <== NOT EXECUTED return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 10b714: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b717: a1 40 b4 12 00 mov 0x12b440,%eax <== NOT EXECUTED 10b71c: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10b71f: e8 08 e2 00 00 call 11992c <== NOT EXECUTED status = error_flag & ~RTEMS_ERROR_MASK; 10b724: 89 f3 mov %esi,%ebx <== NOT EXECUTED 10b726: 81 e3 ff ff ff 8f and $0x8fffffff,%ebx <== NOT EXECUTED if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 10b72c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b72f: f7 c6 00 00 00 40 test $0x40000000,%esi <== NOT EXECUTED 10b735: 0f 85 c1 00 00 00 jne 10b7fc <== NOT EXECUTED 10b73b: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== 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); 10b742: 50 push %eax <== NOT EXECUTED 10b743: 57 push %edi <== NOT EXECUTED 10b744: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 10b747: a1 40 b4 12 00 mov 0x12b440,%eax <== NOT EXECUTED 10b74c: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b74f: e8 38 38 01 00 call 11ef8c <== NOT EXECUTED 10b754: 89 c7 mov %eax,%edi <== NOT EXECUTED if (status) 10b756: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b759: 85 db test %ebx,%ebx <== NOT EXECUTED 10b75b: 0f 85 b7 00 00 00 jne 10b818 <== NOT EXECUTED chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); if (local_errno) 10b761: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 10b765: 74 34 je 10b79b <== NOT EXECUTED { if ((local_errno > 0) && *strerror(local_errno)) 10b767: 7e 17 jle 10b780 <== NOT EXECUTED 10b769: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b76c: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10b76f: e8 6c 0d 01 00 call 11c4e0 <== NOT EXECUTED 10b774: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b777: 80 38 00 cmpb $0x0,(%eax) <== NOT EXECUTED 10b77a: 0f 85 c8 00 00 00 jne 10b848 <== NOT EXECUTED chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); else chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno); 10b780: 53 push %ebx <== NOT EXECUTED 10b781: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10b784: 68 ca 43 12 00 push $0x1243ca <== NOT EXECUTED 10b789: a1 40 b4 12 00 mov 0x12b440,%eax <== NOT EXECUTED 10b78e: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b791: e8 fa e6 00 00 call 119e90 <== NOT EXECUTED 10b796: 01 c7 add %eax,%edi <== NOT EXECUTED 10b798: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } chars_written += fprintf(stderr, "\n"); 10b79b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b79e: 68 20 4d 12 00 push $0x124d20 <== NOT EXECUTED 10b7a3: a1 40 b4 12 00 mov 0x12b440,%eax <== NOT EXECUTED 10b7a8: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b7ab: e8 e0 e6 00 00 call 119e90 <== NOT EXECUTED 10b7b0: 89 c3 mov %eax,%ebx <== NOT EXECUTED (void) fflush(stderr); 10b7b2: 59 pop %ecx <== NOT EXECUTED 10b7b3: a1 40 b4 12 00 mov 0x12b440,%eax <== NOT EXECUTED 10b7b8: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b7bb: e8 6c e1 00 00 call 11992c <== NOT EXECUTED if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT)) 10b7c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b7c3: 81 e6 00 00 00 30 and $0x30000000,%esi <== NOT EXECUTED 10b7c9: 74 41 je 10b80c <== NOT EXECUTED { if (error_flag & RTEMS_ERROR_PANIC) 10b7cb: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10b7ce: 85 d2 test %edx,%edx <== NOT EXECUTED 10b7d0: 0f 84 8b 00 00 00 je 10b861 <== NOT EXECUTED { rtems_error(0, "fatal error, exiting"); 10b7d6: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b7d9: 68 de 43 12 00 push $0x1243de <== NOT EXECUTED 10b7de: 6a 00 push $0x0 <== NOT EXECUTED 10b7e0: e8 ab 00 00 00 call 10b890 <== NOT EXECUTED _exit(local_errno); 10b7e5: 58 pop %eax <== NOT EXECUTED 10b7e6: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10b7e9: e8 fa 06 00 00 call 10bee8 <_exit> <== NOT EXECUTED 10b7ee: 66 90 xchg %ax,%ax <== NOT EXECUTED } else { rtems_error(0, "fatal error, aborting"); abort(); 10b7f0: 31 c0 xor %eax,%eax <== NOT EXECUTED } } return chars_written; } 10b7f2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b7f5: 5b pop %ebx <== NOT EXECUTED 10b7f6: 5e pop %esi <== NOT EXECUTED 10b7f7: 5f pop %edi <== NOT EXECUTED 10b7f8: c9 leave <== NOT EXECUTED 10b7f9: c3 ret <== NOT EXECUTED 10b7fa: 66 90 xchg %ax,%ax <== 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; 10b7fc: e8 7b de 00 00 call 11967c <__errno> <== NOT EXECUTED 10b801: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10b803: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 10b806: e9 37 ff ff ff jmp 10b742 <== NOT EXECUTED 10b80b: 90 nop <== 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"); 10b80c: 8d 04 3b lea (%ebx,%edi,1),%eax <== NOT EXECUTED rtems_error(0, "fatal error, aborting"); abort(); } } return chars_written; } 10b80f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b812: 5b pop %ebx <== NOT EXECUTED 10b813: 5e pop %esi <== NOT EXECUTED 10b814: 5f pop %edi <== NOT EXECUTED 10b815: c9 leave <== NOT EXECUTED 10b816: c3 ret <== NOT EXECUTED 10b817: 90 nop <== NOT EXECUTED const char * rtems_status_text( rtems_status_code status ) { return rtems_assoc_name_by_local(rtems_status_assoc, status); 10b818: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b81b: 53 push %ebx <== NOT EXECUTED 10b81c: 68 c0 46 12 00 push $0x1246c0 <== NOT EXECUTED 10b821: e8 5a 95 00 00 call 114d80 <== NOT EXECUTED #endif chars_written += vfprintf(stderr, printf_format, arglist); if (status) chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); 10b826: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10b829: 50 push %eax <== NOT EXECUTED 10b82a: 68 af 43 12 00 push $0x1243af <== NOT EXECUTED 10b82f: a1 40 b4 12 00 mov 0x12b440,%eax <== NOT EXECUTED 10b834: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b837: e8 54 e6 00 00 call 119e90 <== NOT EXECUTED 10b83c: 01 c7 add %eax,%edi <== NOT EXECUTED 10b83e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b841: e9 1b ff ff ff jmp 10b761 <== NOT EXECUTED 10b846: 66 90 xchg %ax,%ax <== NOT EXECUTED if (local_errno) { if ((local_errno > 0) && *strerror(local_errno)) chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); 10b848: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b84b: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10b84e: e8 8d 0c 01 00 call 11c4e0 <== NOT EXECUTED 10b853: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10b856: 50 push %eax <== NOT EXECUTED 10b857: 68 bd 43 12 00 push $0x1243bd <== NOT EXECUTED 10b85c: e9 28 ff ff ff jmp 10b789 <== NOT EXECUTED rtems_error(0, "fatal error, exiting"); _exit(local_errno); } else { rtems_error(0, "fatal error, aborting"); 10b861: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b864: 68 f3 43 12 00 push $0x1243f3 <== NOT EXECUTED 10b869: 6a 00 push $0x0 <== NOT EXECUTED 10b86b: e8 20 00 00 00 call 10b890 <== NOT EXECUTED abort(); 10b870: e8 d3 dd 00 00 call 119648 <== NOT EXECUTED 0010b09c : */ bool rtems_workspace_allocate( uintptr_t bytes, void **pointer ) { 10b09c: 55 push %ebp <== NOT EXECUTED 10b09d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b09f: 53 push %ebx <== NOT EXECUTED 10b0a0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b0a3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b0a6: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED void *ptr; /* * check the arguments */ if ( !pointer ) 10b0a9: 85 db test %ebx,%ebx <== NOT EXECUTED 10b0ab: 74 04 je 10b0b1 <== NOT EXECUTED return false; if ( !bytes ) 10b0ad: 85 c0 test %eax,%eax <== NOT EXECUTED 10b0af: 75 07 jne 10b0b8 <== NOT EXECUTED ptr = _Protected_heap_Allocate( &_Workspace_Area, (intptr_t) bytes ); if (!ptr) return false; *pointer = ptr; return true; 10b0b1: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10b0b3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b0b6: c9 leave <== NOT EXECUTED 10b0b7: c3 ret <== NOT EXECUTED return false; /* * Allocate the memory */ ptr = _Protected_heap_Allocate( &_Workspace_Area, (intptr_t) bytes ); 10b0b8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b0bb: 50 push %eax <== NOT EXECUTED 10b0bc: 68 c0 3c 12 00 push $0x123cc0 <== NOT EXECUTED 10b0c1: e8 b2 15 00 00 call 10c678 <_Protected_heap_Allocate> <== NOT EXECUTED if (!ptr) 10b0c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b0c9: 85 c0 test %eax,%eax <== NOT EXECUTED 10b0cb: 74 e4 je 10b0b1 <== NOT EXECUTED return false; *pointer = ptr; 10b0cd: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10b0cf: b0 01 mov $0x1,%al <== NOT EXECUTED return true; } 10b0d1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b0d4: c9 leave <== NOT EXECUTED 10b0d5: c3 ret <== NOT EXECUTED 0010b084 : * _Workspace_Allocate */ bool rtems_workspace_free( void *pointer ) { 10b084: 55 push %ebp <== NOT EXECUTED 10b085: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b087: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Protected_heap_Free( &_Workspace_Area, pointer ); 10b08a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b08d: 68 c0 3c 12 00 push $0x123cc0 <== NOT EXECUTED 10b092: e8 15 16 00 00 call 10c6ac <_Protected_heap_Free> <== NOT EXECUTED } 10b097: c9 leave <== NOT EXECUTED 10b098: c3 ret <== NOT EXECUTED 0010b0d8 : #include /* for memset */ bool rtems_workspace_get_information( Heap_Information_block *the_info ) { 10b0d8: 55 push %ebp <== NOT EXECUTED 10b0d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b0db: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b0de: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !the_info ) 10b0e1: 85 c0 test %eax,%eax <== NOT EXECUTED 10b0e3: 74 11 je 10b0f6 <== NOT EXECUTED return false; return _Protected_heap_Get_information( &_Workspace_Area, the_info ); 10b0e5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b0e8: 50 push %eax <== NOT EXECUTED 10b0e9: 68 c0 3c 12 00 push $0x123cc0 <== NOT EXECUTED 10b0ee: e8 ed 15 00 00 call 10c6e0 <_Protected_heap_Get_information> <== NOT EXECUTED 10b0f3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b0f6: c9 leave <== NOT EXECUTED 10b0f7: c3 ret <== NOT EXECUTED 00123fc4 : /* * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) { 123fc4: 55 push %ebp <== NOT EXECUTED 123fc5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123fc7: 57 push %edi <== NOT EXECUTED 123fc8: 56 push %esi <== NOT EXECUTED 123fc9: 53 push %ebx <== NOT EXECUTED 123fca: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123fcd: 89 c6 mov %eax,%esi <== NOT EXECUTED 123fcf: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED 123fd2: 31 db xor %ebx,%ebx <== NOT EXECUTED 123fd4: c7 45 f0 ff ff ff 7f movl $0x7fffffff,-0x10(%ebp) <== NOT EXECUTED 123fdb: 31 ff xor %edi,%edi <== NOT EXECUTED unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 123fdd: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 123fe0: 48 dec %eax <== NOT EXECUTED 123fe1: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 123fe4: 85 c0 test %eax,%eax <== NOT EXECUTED 123fe6: 78 51 js 124039 <== NOT EXECUTED 123fe8: 8b 06 mov (%esi),%eax <== NOT EXECUTED 123fea: 0f b6 08 movzbl (%eax),%ecx <== NOT EXECUTED 123fed: 40 inc %eax <== NOT EXECUTED 123fee: 89 06 mov %eax,(%esi) <== NOT EXECUTED if (c == ':') 123ff0: 83 f9 3a cmp $0x3a,%ecx <== NOT EXECUTED 123ff3: 74 5f je 124054 <== NOT EXECUTED break; if (sign == 0) { 123ff5: 85 ff test %edi,%edi <== NOT EXECUTED 123ff7: 75 0e jne 124007 <== NOT EXECUTED if (c == '-') { 123ff9: 83 f9 2d cmp $0x2d,%ecx <== NOT EXECUTED 123ffc: 0f 84 8a 00 00 00 je 12408c <== NOT EXECUTED sign = -1; limit++; continue; 124002: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED } sign = 1; } if (!isdigit(c)) 124007: a1 28 cb 14 00 mov 0x14cb28,%eax <== NOT EXECUTED 12400c: f6 04 08 04 testb $0x4,(%eax,%ecx,1) <== NOT EXECUTED 124010: 74 6e je 124080 <== NOT EXECUTED return 0; d = c - '0'; if ((i > (limit / 10)) 124012: b8 cd cc cc cc mov $0xcccccccd,%eax <== NOT EXECUTED 124017: f7 65 f0 mull -0x10(%ebp) <== NOT EXECUTED 12401a: c1 ea 03 shr $0x3,%edx <== NOT EXECUTED 12401d: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 12401f: 77 5f ja 124080 <== NOT EXECUTED } sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; 124021: 83 e9 30 sub $0x30,%ecx <== NOT EXECUTED if ((i > (limit / 10)) 124024: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 124026: 74 48 je 124070 <== NOT EXECUTED || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; i = i * 10 + d; 124028: 8d 04 9b lea (%ebx,%ebx,4),%eax <== NOT EXECUTED 12402b: 8d 1c 41 lea (%ecx,%eax,2),%ebx <== NOT EXECUTED unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 12402e: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 124031: 48 dec %eax <== NOT EXECUTED 124032: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 124035: 85 c0 test %eax,%eax <== NOT EXECUTED 124037: 79 af jns 123fe8 <== NOT EXECUTED 124039: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12403c: 56 push %esi <== NOT EXECUTED 12403d: ff 35 40 cb 14 00 pushl 0x14cb40 <== NOT EXECUTED 124043: e8 94 15 01 00 call 1355dc <__srget_r> <== NOT EXECUTED 124048: 89 c1 mov %eax,%ecx <== NOT EXECUTED 12404a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (c == ':') 12404d: 83 f9 3a cmp $0x3a,%ecx <== NOT EXECUTED 124050: 75 a3 jne 123ff5 <== NOT EXECUTED 124052: 66 90 xchg %ax,%ax <== NOT EXECUTED if ((i > (limit / 10)) || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; i = i * 10 + d; } if (sign == 0) 124054: 85 ff test %edi,%edi <== NOT EXECUTED 124056: 74 28 je 124080 <== NOT EXECUTED return 0; *val = i * sign; 124058: 0f af fb imul %ebx,%edi <== NOT EXECUTED 12405b: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 12405e: 89 38 mov %edi,(%eax) <== NOT EXECUTED 124060: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED return 1; } 124065: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124068: 5b pop %ebx <== NOT EXECUTED 124069: 5e pop %esi <== NOT EXECUTED 12406a: 5f pop %edi <== NOT EXECUTED 12406b: c9 leave <== NOT EXECUTED 12406c: c3 ret <== NOT EXECUTED 12406d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; if ((i > (limit / 10)) 124070: 8d 04 9b lea (%ebx,%ebx,4),%eax <== NOT EXECUTED 124073: d1 e0 shl %eax <== NOT EXECUTED 124075: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 124078: 29 c2 sub %eax,%edx <== NOT EXECUTED 12407a: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 12407c: 76 aa jbe 124028 <== NOT EXECUTED 12407e: 66 90 xchg %ax,%ax <== NOT EXECUTED i = i * 10 + d; } if (sign == 0) return 0; *val = i * sign; return 1; 124080: 31 c0 xor %eax,%eax <== NOT EXECUTED } 124082: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124085: 5b pop %ebx <== NOT EXECUTED 124086: 5e pop %esi <== NOT EXECUTED 124087: 5f pop %edi <== NOT EXECUTED 124088: c9 leave <== NOT EXECUTED 124089: c3 ret <== NOT EXECUTED 12408a: 66 90 xchg %ax,%ax <== NOT EXECUTED if (c == ':') break; if (sign == 0) { if (c == '-') { sign = -1; limit++; 12408c: ff 45 f0 incl -0x10(%ebp) <== NOT EXECUTED 12408f: bf ff ff ff ff mov $0xffffffff,%edi <== NOT EXECUTED 124094: e9 44 ff ff ff jmp 123fdd <== NOT EXECUTED 0012409c : /* * Extract a string value from the database */ static int scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag) { 12409c: 55 push %ebp <== NOT EXECUTED 12409d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12409f: 57 push %edi <== NOT EXECUTED 1240a0: 56 push %esi <== NOT EXECUTED 1240a1: 53 push %ebx <== NOT EXECUTED 1240a2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1240a5: 89 c6 mov %eax,%esi <== NOT EXECUTED 1240a7: 89 cb mov %ecx,%ebx <== NOT EXECUTED 1240a9: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED int c; *name = *bufp; 1240ac: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 1240ae: 89 02 mov %eax,(%edx) <== NOT EXECUTED 1240b0: eb 26 jmp 1240d8 <== NOT EXECUTED 1240b2: 66 90 xchg %ax,%ax <== NOT EXECUTED for (;;) { c = getc(fp); 1240b4: 8b 06 mov (%esi),%eax <== NOT EXECUTED 1240b6: 0f b6 10 movzbl (%eax),%edx <== NOT EXECUTED 1240b9: 40 inc %eax <== NOT EXECUTED 1240ba: 89 06 mov %eax,(%esi) <== NOT EXECUTED if (c == ':') { 1240bc: 83 fa 3a cmp $0x3a,%edx <== NOT EXECUTED 1240bf: 74 3b je 1240fc <== NOT EXECUTED if (nlFlag) return 0; break; } if (c == '\n') { 1240c1: 83 fa 0a cmp $0xa,%edx <== NOT EXECUTED 1240c4: 74 56 je 12411c <== NOT EXECUTED if (!nlFlag) return 0; break; } if (c == EOF) 1240c6: 83 fa ff cmp $0xffffffff,%edx <== NOT EXECUTED 1240c9: 74 59 je 124124 <== NOT EXECUTED return 0; if (*nleft < 2) 1240cb: 83 3f 01 cmpl $0x1,(%edi) <== NOT EXECUTED 1240ce: 76 54 jbe 124124 <== NOT EXECUTED return 0; **bufp = c; 1240d0: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 1240d2: 88 10 mov %dl,(%eax) <== NOT EXECUTED ++(*bufp); 1240d4: ff 03 incl (%ebx) <== NOT EXECUTED --(*nleft); 1240d6: ff 0f decl (%edi) <== NOT EXECUTED { int c; *name = *bufp; for (;;) { c = getc(fp); 1240d8: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 1240db: 48 dec %eax <== NOT EXECUTED 1240dc: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 1240df: 85 c0 test %eax,%eax <== NOT EXECUTED 1240e1: 79 d1 jns 1240b4 <== NOT EXECUTED 1240e3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1240e6: 56 push %esi <== NOT EXECUTED 1240e7: ff 35 40 cb 14 00 pushl 0x14cb40 <== NOT EXECUTED 1240ed: e8 ea 14 01 00 call 1355dc <__srget_r> <== NOT EXECUTED 1240f2: 89 c2 mov %eax,%edx <== NOT EXECUTED 1240f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (c == ':') { 1240f7: 83 fa 3a cmp $0x3a,%edx <== NOT EXECUTED 1240fa: 75 c5 jne 1240c1 <== NOT EXECUTED if (nlFlag) 1240fc: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 1240ff: 85 d2 test %edx,%edx <== NOT EXECUTED 124101: 75 21 jne 124124 <== NOT EXECUTED return 0; **bufp = c; ++(*bufp); --(*nleft); } **bufp = '\0'; 124103: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 124105: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED ++(*bufp); 124108: ff 03 incl (%ebx) <== NOT EXECUTED --(*nleft); 12410a: ff 0f decl (%edi) <== NOT EXECUTED 12410c: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED return 1; } 124111: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124114: 5b pop %ebx <== NOT EXECUTED 124115: 5e pop %esi <== NOT EXECUTED 124116: 5f pop %edi <== NOT EXECUTED 124117: c9 leave <== NOT EXECUTED 124118: c3 ret <== NOT EXECUTED 124119: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (nlFlag) return 0; break; } if (c == '\n') { if (!nlFlag) 12411c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 12411f: 85 c0 test %eax,%eax <== NOT EXECUTED 124121: 75 e0 jne 124103 <== NOT EXECUTED 124123: 90 nop <== NOT EXECUTED --(*nleft); } **bufp = '\0'; ++(*bufp); --(*nleft); return 1; 124124: 31 c0 xor %eax,%eax <== NOT EXECUTED } 124126: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124129: 5b pop %ebx <== NOT EXECUTED 12412a: 5e pop %esi <== NOT EXECUTED 12412b: 5f pop %edi <== NOT EXECUTED 12412c: c9 leave <== NOT EXECUTED 12412d: c3 ret <== NOT EXECUTED 00109f60 : scandir( const char *dirname, struct dirent ***namelist, int (*select)(struct dirent *), int (*dcomp)(const struct dirent **, const struct dirent **)) { 109f60: 55 push %ebp <== NOT EXECUTED 109f61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109f63: 57 push %edi <== NOT EXECUTED 109f64: 56 push %esi <== NOT EXECUTED 109f65: 53 push %ebx <== NOT EXECUTED 109f66: 83 ec 68 sub $0x68,%esp <== NOT EXECUTED struct stat stb; long arraysz; DIR *dirp = NULL; int i; if ((dirp = opendir(dirname)) == NULL) 109f69: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 109f6c: e8 8b f7 ff ff call 1096fc <== NOT EXECUTED 109f71: 89 45 a0 mov %eax,-0x60(%ebp) <== NOT EXECUTED 109f74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109f77: 85 c0 test %eax,%eax <== NOT EXECUTED 109f79: 0f 84 99 01 00 00 je 10a118 <== NOT EXECUTED return(-1); if (fstat(dirp->dd_fd, &stb) < 0) 109f7f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109f82: 8d 45 a8 lea -0x58(%ebp),%eax <== NOT EXECUTED 109f85: 50 push %eax <== NOT EXECUTED 109f86: 8b 55 a0 mov -0x60(%ebp),%edx <== NOT EXECUTED 109f89: ff 32 pushl (%edx) <== NOT EXECUTED 109f8b: e8 6c 6b 00 00 call 110afc <== NOT EXECUTED 109f90: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109f93: 85 c0 test %eax,%eax <== NOT EXECUTED 109f95: 0f 88 1b 01 00 00 js 10a0b6 <== NOT EXECUTED /* * 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); 109f9b: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 109f9e: bb ab aa aa 2a mov $0x2aaaaaab,%ebx <== NOT EXECUTED 109fa3: 89 c8 mov %ecx,%eax <== NOT EXECUTED 109fa5: f7 eb imul %ebx <== NOT EXECUTED 109fa7: 89 d7 mov %edx,%edi <== NOT EXECUTED 109fa9: c1 ff 02 sar $0x2,%edi <== NOT EXECUTED 109fac: 89 c8 mov %ecx,%eax <== NOT EXECUTED 109fae: c1 f8 1f sar $0x1f,%eax <== NOT EXECUTED 109fb1: 29 c7 sub %eax,%edi <== NOT EXECUTED names = (struct dirent **)malloc(arraysz * sizeof(struct dirent *)); 109fb3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109fb6: 8d 04 bd 00 00 00 00 lea 0x0(,%edi,4),%eax <== NOT EXECUTED 109fbd: 50 push %eax <== NOT EXECUTED 109fbe: e8 b9 ee ff ff call 108e7c <== NOT EXECUTED 109fc3: 89 45 98 mov %eax,-0x68(%ebp) <== NOT EXECUTED if (names == NULL) 109fc6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109fc9: 85 c0 test %eax,%eax <== NOT EXECUTED 109fcb: 0f 84 e5 00 00 00 je 10a0b6 <== NOT EXECUTED goto cleanup_and_bail; 109fd1: c7 45 9c 00 00 00 00 movl $0x0,-0x64(%ebp) <== NOT EXECUTED while ((d = readdir(dirp)) != NULL) { 109fd8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109fdb: ff 75 a0 pushl -0x60(%ebp) <== NOT EXECUTED 109fde: e8 85 fd ff ff call 109d68 <== NOT EXECUTED 109fe3: 89 c3 mov %eax,%ebx <== NOT EXECUTED 109fe5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109fe8: 85 c0 test %eax,%eax <== NOT EXECUTED 109fea: 0f 84 e4 00 00 00 je 10a0d4 <== NOT EXECUTED if (select != NULL && !(*select)(d)) 109ff0: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 109ff3: 85 c9 test %ecx,%ecx <== NOT EXECUTED 109ff5: 74 0e je 10a005 <== NOT EXECUTED 109ff7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109ffa: 53 push %ebx <== NOT EXECUTED 109ffb: ff 55 10 call *0x10(%ebp) <== NOT EXECUTED 109ffe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a001: 85 c0 test %eax,%eax <== NOT EXECUTED 10a003: 74 d3 je 109fd8 <== NOT EXECUTED continue; /* just selected names */ /* * Make a minimum size copy of the data */ p = (struct dirent *)malloc(DIRSIZ(d)); 10a005: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a008: 0f b7 43 0a movzwl 0xa(%ebx),%eax <== NOT EXECUTED 10a00c: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 10a00f: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 10a012: 83 c0 0c add $0xc,%eax <== NOT EXECUTED 10a015: 50 push %eax <== NOT EXECUTED 10a016: e8 61 ee ff ff call 108e7c <== NOT EXECUTED 10a01b: 89 c6 mov %eax,%esi <== NOT EXECUTED if (p == NULL) 10a01d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a020: 85 c0 test %eax,%eax <== NOT EXECUTED 10a022: 0f 84 00 01 00 00 je 10a128 <== NOT EXECUTED goto cleanup_and_bail; p->d_ino = d->d_ino; 10a028: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10a02a: 89 06 mov %eax,(%esi) <== NOT EXECUTED p->d_reclen = d->d_reclen; 10a02c: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10a02f: 66 89 46 08 mov %ax,0x8(%esi) <== NOT EXECUTED p->d_namlen = d->d_namlen; 10a033: 0f b7 43 0a movzwl 0xa(%ebx),%eax <== NOT EXECUTED 10a037: 66 89 46 0a mov %ax,0xa(%esi) <== NOT EXECUTED strncpy(p->d_name, d->d_name, p->d_namlen + 1); 10a03b: 52 push %edx <== NOT EXECUTED 10a03c: 40 inc %eax <== NOT EXECUTED 10a03d: 50 push %eax <== NOT EXECUTED 10a03e: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED 10a041: 50 push %eax <== NOT EXECUTED 10a042: 8d 46 0c lea 0xc(%esi),%eax <== NOT EXECUTED 10a045: 50 push %eax <== NOT EXECUTED 10a046: e8 61 b8 00 00 call 1158ac <== NOT EXECUTED /* * Check to make sure the array has space left and * realloc the maximum size. */ if (++nitems >= arraysz) { 10a04b: ff 45 9c incl -0x64(%ebp) <== NOT EXECUTED 10a04e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a051: 39 7d 9c cmp %edi,-0x64(%ebp) <== NOT EXECUTED 10a054: 73 12 jae 10a068 <== NOT EXECUTED names = (struct dirent **)realloc((char *)names, arraysz * sizeof(struct dirent *)); if (names == NULL) goto cleanup_and_bail; } names[nitems-1] = p; 10a056: 8b 45 9c mov -0x64(%ebp),%eax <== NOT EXECUTED 10a059: 83 e8 01 sub $0x1,%eax <== NOT EXECUTED 10a05c: 8b 55 98 mov -0x68(%ebp),%edx <== NOT EXECUTED 10a05f: 89 34 82 mov %esi,(%edx,%eax,4) <== NOT EXECUTED 10a062: e9 71 ff ff ff jmp 109fd8 <== NOT EXECUTED 10a067: 90 nop <== NOT EXECUTED /* * Check to make sure the array has space left and * realloc the maximum size. */ if (++nitems >= arraysz) { if (fstat(dirp->dd_fd, &stb) < 0) 10a068: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a06b: 8d 45 a8 lea -0x58(%ebp),%eax <== NOT EXECUTED 10a06e: 50 push %eax <== NOT EXECUTED 10a06f: 8b 55 a0 mov -0x60(%ebp),%edx <== NOT EXECUTED 10a072: ff 32 pushl (%edx) <== NOT EXECUTED 10a074: e8 83 6a 00 00 call 110afc <== NOT EXECUTED 10a079: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a07c: 85 c0 test %eax,%eax <== NOT EXECUTED 10a07e: 0f 88 a4 00 00 00 js 10a128 <== NOT EXECUTED goto cleanup_and_bail; /* just might have grown */ arraysz = stb.st_size / 12; 10a084: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 10a087: b8 ab aa aa 2a mov $0x2aaaaaab,%eax <== NOT EXECUTED 10a08c: f7 e9 imul %ecx <== NOT EXECUTED 10a08e: 89 d7 mov %edx,%edi <== NOT EXECUTED 10a090: d1 ff sar %edi <== NOT EXECUTED 10a092: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10a094: c1 f8 1f sar $0x1f,%eax <== NOT EXECUTED 10a097: 29 c7 sub %eax,%edi <== NOT EXECUTED names = (struct dirent **)realloc((char *)names, 10a099: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a09c: 8d 04 bd 00 00 00 00 lea 0x0(,%edi,4),%eax <== NOT EXECUTED 10a0a3: 50 push %eax <== NOT EXECUTED 10a0a4: ff 75 98 pushl -0x68(%ebp) <== NOT EXECUTED 10a0a7: e8 84 6c 00 00 call 110d30 <== NOT EXECUTED 10a0ac: 89 45 98 mov %eax,-0x68(%ebp) <== NOT EXECUTED arraysz * sizeof(struct dirent *)); if (names == NULL) 10a0af: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0b2: 85 c0 test %eax,%eax <== NOT EXECUTED 10a0b4: 75 a0 jne 10a056 <== NOT EXECUTED return(nitems); cleanup_and_bail: if ( dirp ) closedir( dirp ); 10a0b6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a0b9: ff 75 a0 pushl -0x60(%ebp) <== NOT EXECUTED 10a0bc: e8 43 e3 ff ff call 108404 <== NOT EXECUTED 10a0c1: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a0c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free( names[i] ); free( names ); } return(-1); } 10a0c9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a0cc: 5b pop %ebx <== NOT EXECUTED 10a0cd: 5e pop %esi <== NOT EXECUTED 10a0ce: 5f pop %edi <== NOT EXECUTED 10a0cf: c9 leave <== NOT EXECUTED 10a0d0: c3 ret <== NOT EXECUTED 10a0d1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (names == NULL) goto cleanup_and_bail; } names[nitems-1] = p; } closedir(dirp); 10a0d4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a0d7: ff 75 a0 pushl -0x60(%ebp) <== NOT EXECUTED 10a0da: e8 25 e3 ff ff call 108404 <== NOT EXECUTED if (nitems && dcomp != NULL){ 10a0df: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a0e2: 8b 4d 9c mov -0x64(%ebp),%ecx <== NOT EXECUTED 10a0e5: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a0e7: 74 1a je 10a103 <== NOT EXECUTED 10a0e9: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10a0ec: 85 d2 test %edx,%edx <== NOT EXECUTED 10a0ee: 74 13 je 10a103 <== NOT EXECUTED qsort(names, nitems, sizeof(struct dirent *), 10a0f0: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10a0f3: 6a 04 push $0x4 <== NOT EXECUTED 10a0f5: ff 75 9c pushl -0x64(%ebp) <== NOT EXECUTED 10a0f8: ff 75 98 pushl -0x68(%ebp) <== NOT EXECUTED 10a0fb: e8 cc ac 00 00 call 114dcc <== NOT EXECUTED 10a100: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (int (*)(const void *, const void *)) dcomp); } *namelist = names; 10a103: 8b 55 98 mov -0x68(%ebp),%edx <== NOT EXECUTED 10a106: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a109: 89 10 mov %edx,(%eax) <== NOT EXECUTED return(nitems); 10a10b: 8b 45 9c mov -0x64(%ebp),%eax <== NOT EXECUTED free( names[i] ); free( names ); } return(-1); } 10a10e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a111: 5b pop %ebx <== NOT EXECUTED 10a112: 5e pop %esi <== NOT EXECUTED 10a113: 5f pop %edi <== NOT EXECUTED 10a114: c9 leave <== NOT EXECUTED 10a115: c3 ret <== NOT EXECUTED 10a116: 66 90 xchg %ax,%ax <== NOT EXECUTED struct stat stb; long arraysz; DIR *dirp = NULL; int i; if ((dirp = opendir(dirname)) == NULL) 10a118: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED free( names[i] ); free( names ); } return(-1); } 10a11d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10a120: 5b pop %ebx <== NOT EXECUTED 10a121: 5e pop %esi <== NOT EXECUTED 10a122: 5f pop %edi <== NOT EXECUTED 10a123: c9 leave <== NOT EXECUTED 10a124: c3 ret <== NOT EXECUTED 10a125: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return(nitems); cleanup_and_bail: if ( dirp ) closedir( dirp ); 10a128: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a12b: ff 75 a0 pushl -0x60(%ebp) <== NOT EXECUTED 10a12e: e8 d1 e2 ff ff call 108404 <== NOT EXECUTED if ( names ) { for (i=0; i < nitems; i++ ) 10a133: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a136: 8b 45 9c mov -0x64(%ebp),%eax <== NOT EXECUTED 10a139: 85 c0 test %eax,%eax <== NOT EXECUTED 10a13b: 74 1d je 10a15a <== NOT EXECUTED 10a13d: 31 db xor %ebx,%ebx <== NOT EXECUTED 10a13f: 31 c0 xor %eax,%eax <== NOT EXECUTED free( names[i] ); 10a141: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a144: 8b 55 98 mov -0x68(%ebp),%edx <== NOT EXECUTED 10a147: ff 34 82 pushl (%edx,%eax,4) <== NOT EXECUTED 10a14a: e8 71 e7 ff ff call 1088c0 <== NOT EXECUTED if ( dirp ) closedir( dirp ); if ( names ) { for (i=0; i < nitems; i++ ) 10a14f: 43 inc %ebx <== NOT EXECUTED 10a150: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a152: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a155: 39 5d 9c cmp %ebx,-0x64(%ebp) <== NOT EXECUTED 10a158: 77 e7 ja 10a141 <== NOT EXECUTED free( names[i] ); free( names ); 10a15a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a15d: ff 75 98 pushl -0x68(%ebp) <== NOT EXECUTED 10a160: e8 5b e7 ff ff call 1088c0 <== NOT EXECUTED 10a165: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a16a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a16d: eb 9f jmp 10a10e <== NOT EXECUTED 00124130 : FILE *fp, struct group *grp, char *buffer, size_t bufsize ) { 124130: 55 push %ebp <== NOT EXECUTED 124131: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124133: 57 push %edi <== NOT EXECUTED 124134: 56 push %esi <== NOT EXECUTED 124135: 53 push %ebx <== NOT EXECUTED 124136: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 124139: 89 c3 mov %eax,%ebx <== NOT EXECUTED 12413b: 89 d7 mov %edx,%edi <== NOT EXECUTED 12413d: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 124140: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED 124143: 6a 00 push $0x0 <== NOT EXECUTED 124145: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 124148: 50 push %eax <== NOT EXECUTED 124149: 89 f1 mov %esi,%ecx <== NOT EXECUTED 12414b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12414d: e8 4a ff ff ff call 12409c <== NOT EXECUTED 124152: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124155: 85 c0 test %eax,%eax <== NOT EXECUTED 124157: 75 0b jne 124164 <== NOT EXECUTED *cp = '\0'; grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; return 1; 124159: 31 c0 xor %eax,%eax <== NOT EXECUTED } 12415b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12415e: 5b pop %ebx <== NOT EXECUTED 12415f: 5e pop %esi <== NOT EXECUTED 124160: 5f pop %edi <== NOT EXECUTED 124161: c9 leave <== NOT EXECUTED 124162: c3 ret <== NOT EXECUTED 124163: 90 nop <== NOT EXECUTED { int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 124164: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124167: 8d 57 04 lea 0x4(%edi),%edx <== NOT EXECUTED 12416a: 6a 00 push $0x0 <== NOT EXECUTED 12416c: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 12416f: 50 push %eax <== NOT EXECUTED 124170: 89 f1 mov %esi,%ecx <== NOT EXECUTED 124172: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124174: e8 23 ff ff ff call 12409c <== NOT EXECUTED 124179: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12417c: 85 c0 test %eax,%eax <== NOT EXECUTED 12417e: 74 d9 je 124159 <== NOT EXECUTED 124180: 8d 55 f0 lea -0x10(%ebp),%edx <== NOT EXECUTED 124183: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124185: e8 3a fe ff ff call 123fc4 <== NOT EXECUTED 12418a: 85 c0 test %eax,%eax <== NOT EXECUTED 12418c: 74 cb je 124159 <== NOT EXECUTED 12418e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124191: 8d 55 ec lea -0x14(%ebp),%edx <== NOT EXECUTED 124194: 6a 01 push $0x1 <== NOT EXECUTED 124196: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 124199: 50 push %eax <== NOT EXECUTED 12419a: 89 f1 mov %esi,%ecx <== NOT EXECUTED 12419c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12419e: e8 f9 fe ff ff call 12409c <== NOT EXECUTED 1241a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1241a6: 85 c0 test %eax,%eax <== NOT EXECUTED 1241a8: 74 af je 124159 <== 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; 1241aa: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1241ad: 66 89 47 08 mov %ax,0x8(%edi) <== NOT EXECUTED /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 1241b1: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 1241b4: 8a 03 mov (%ebx),%al <== NOT EXECUTED 1241b6: 84 c0 test %al,%al <== NOT EXECUTED 1241b8: 74 7d je 124237 <== NOT EXECUTED 1241ba: 89 da mov %ebx,%edx <== NOT EXECUTED 1241bc: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 1241c1: eb 08 jmp 1241cb <== NOT EXECUTED 1241c3: 90 nop <== NOT EXECUTED 1241c4: 42 inc %edx <== NOT EXECUTED 1241c5: 8a 02 mov (%edx),%al <== NOT EXECUTED 1241c7: 84 c0 test %al,%al <== NOT EXECUTED 1241c9: 74 09 je 1241d4 <== NOT EXECUTED if(*cp == ',') 1241cb: 3c 2c cmp $0x2c,%al <== NOT EXECUTED 1241cd: 75 f5 jne 1241c4 <== NOT EXECUTED memcount++; 1241cf: 41 inc %ecx <== NOT EXECUTED 1241d0: eb f2 jmp 1241c4 <== NOT EXECUTED 1241d2: 66 90 xchg %ax,%ax <== NOT EXECUTED grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 1241d4: 8d 04 8d 13 00 00 00 lea 0x13(,%ecx,4),%eax <== NOT EXECUTED } /* * Hack to produce (hopefully) a suitably-aligned array of pointers */ if (bufsize < (((memcount+1)*sizeof(char *)) + 15)) 1241db: 39 45 08 cmp %eax,0x8(%ebp) <== NOT EXECUTED 1241de: 0f 82 75 ff ff ff jb 124159 <== NOT EXECUTED return 0; grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15); 1241e4: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 1241e7: 83 c0 0f add $0xf,%eax <== NOT EXECUTED 1241ea: 83 e0 f0 and $0xfffffff0,%eax <== NOT EXECUTED 1241ed: 89 47 0c mov %eax,0xc(%edi) <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; 1241f0: 89 18 mov %ebx,(%eax) <== NOT EXECUTED for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 1241f2: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 1241f5: 8a 02 mov (%edx),%al <== NOT EXECUTED 1241f7: 84 c0 test %al,%al <== NOT EXECUTED 1241f9: 74 43 je 12423e <== NOT EXECUTED 1241fb: 42 inc %edx <== NOT EXECUTED 1241fc: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 124201: eb 08 jmp 12420b <== NOT EXECUTED 124203: 90 nop <== NOT EXECUTED 124204: 8a 02 mov (%edx),%al <== NOT EXECUTED 124206: 42 inc %edx <== NOT EXECUTED 124207: 84 c0 test %al,%al <== NOT EXECUTED 124209: 74 11 je 12421c <== NOT EXECUTED if(*cp == ',') { 12420b: 3c 2c cmp $0x2c,%al <== NOT EXECUTED 12420d: 75 f5 jne 124204 <== NOT EXECUTED *cp = '\0'; 12420f: c6 42 ff 00 movb $0x0,-0x1(%edx) <== NOT EXECUTED grp->gr_mem[memcount++] = cp + 1; 124213: 8b 47 0c mov 0xc(%edi),%eax <== NOT EXECUTED 124216: 89 14 88 mov %edx,(%eax,%ecx,4) <== NOT EXECUTED 124219: 41 inc %ecx <== NOT EXECUTED 12421a: eb e8 jmp 124204 <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 12421c: 8d 14 8d 00 00 00 00 lea 0x0(,%ecx,4),%edx <== NOT EXECUTED if(*cp == ',') { *cp = '\0'; grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; 124223: 8b 47 0c mov 0xc(%edi),%eax <== NOT EXECUTED 124226: c7 04 10 00 00 00 00 movl $0x0,(%eax,%edx,1) <== NOT EXECUTED 12422d: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 124232: e9 24 ff ff ff jmp 12415b <== NOT EXECUTED grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 124237: b8 17 00 00 00 mov $0x17,%eax <== NOT EXECUTED 12423c: eb 9d jmp 1241db <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 12423e: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 124243: eb de jmp 124223 <== NOT EXECUTED 00124280 : FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) { 124280: 55 push %ebp <== NOT EXECUTED 124281: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124283: 57 push %edi <== NOT EXECUTED 124284: 56 push %esi <== NOT EXECUTED 124285: 53 push %ebx <== NOT EXECUTED 124286: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 124289: 89 c3 mov %eax,%ebx <== NOT EXECUTED 12428b: 89 d6 mov %edx,%esi <== NOT EXECUTED 12428d: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 124290: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 124293: 6a 00 push $0x0 <== NOT EXECUTED 124295: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 124298: 50 push %eax <== NOT EXECUTED 124299: 89 f9 mov %edi,%ecx <== NOT EXECUTED 12429b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12429d: e8 fa fd ff ff call 12409c <== NOT EXECUTED 1242a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1242a5: 85 c0 test %eax,%eax <== NOT EXECUTED 1242a7: 75 0b jne 1242b4 <== NOT EXECUTED || !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; return 1; 1242a9: 31 c0 xor %eax,%eax <== NOT EXECUTED } 1242ab: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1242ae: 5b pop %ebx <== NOT EXECUTED 1242af: 5e pop %esi <== NOT EXECUTED 1242b0: 5f pop %edi <== NOT EXECUTED 1242b1: c9 leave <== NOT EXECUTED 1242b2: c3 ret <== NOT EXECUTED 1242b3: 90 nop <== NOT EXECUTED size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 1242b4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1242b7: 8d 56 04 lea 0x4(%esi),%edx <== NOT EXECUTED 1242ba: 6a 00 push $0x0 <== NOT EXECUTED 1242bc: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 1242bf: 50 push %eax <== NOT EXECUTED 1242c0: 89 f9 mov %edi,%ecx <== NOT EXECUTED 1242c2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1242c4: e8 d3 fd ff ff call 12409c <== NOT EXECUTED 1242c9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1242cc: 85 c0 test %eax,%eax <== NOT EXECUTED 1242ce: 74 d9 je 1242a9 <== NOT EXECUTED 1242d0: 8d 55 f0 lea -0x10(%ebp),%edx <== NOT EXECUTED 1242d3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1242d5: e8 ea fc ff ff call 123fc4 <== NOT EXECUTED 1242da: 85 c0 test %eax,%eax <== NOT EXECUTED 1242dc: 74 cb je 1242a9 <== NOT EXECUTED 1242de: 8d 55 ec lea -0x14(%ebp),%edx <== NOT EXECUTED 1242e1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1242e3: e8 dc fc ff ff call 123fc4 <== NOT EXECUTED 1242e8: 85 c0 test %eax,%eax <== NOT EXECUTED 1242ea: 74 bd je 1242a9 <== NOT EXECUTED 1242ec: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1242ef: 8d 56 0c lea 0xc(%esi),%edx <== NOT EXECUTED 1242f2: 6a 00 push $0x0 <== NOT EXECUTED 1242f4: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 1242f7: 50 push %eax <== NOT EXECUTED 1242f8: 89 f9 mov %edi,%ecx <== NOT EXECUTED 1242fa: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1242fc: e8 9b fd ff ff call 12409c <== NOT EXECUTED 124301: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124304: 85 c0 test %eax,%eax <== NOT EXECUTED 124306: 74 a1 je 1242a9 <== NOT EXECUTED 124308: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12430b: 8d 56 10 lea 0x10(%esi),%edx <== NOT EXECUTED 12430e: 6a 00 push $0x0 <== NOT EXECUTED 124310: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 124313: 50 push %eax <== NOT EXECUTED 124314: 89 f9 mov %edi,%ecx <== NOT EXECUTED 124316: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124318: e8 7f fd ff ff call 12409c <== NOT EXECUTED 12431d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124320: 85 c0 test %eax,%eax <== NOT EXECUTED 124322: 74 85 je 1242a9 <== NOT EXECUTED 124324: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124327: 8d 56 14 lea 0x14(%esi),%edx <== NOT EXECUTED 12432a: 6a 00 push $0x0 <== NOT EXECUTED 12432c: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 12432f: 50 push %eax <== NOT EXECUTED 124330: 89 f9 mov %edi,%ecx <== NOT EXECUTED 124332: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124334: e8 63 fd ff ff call 12409c <== NOT EXECUTED 124339: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12433c: 85 c0 test %eax,%eax <== NOT EXECUTED 12433e: 0f 84 65 ff ff ff je 1242a9 <== NOT EXECUTED 124344: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124347: 8d 56 18 lea 0x18(%esi),%edx <== NOT EXECUTED 12434a: 6a 01 push $0x1 <== NOT EXECUTED 12434c: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 12434f: 50 push %eax <== NOT EXECUTED 124350: 89 f9 mov %edi,%ecx <== NOT EXECUTED 124352: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124354: e8 43 fd ff ff call 12409c <== NOT EXECUTED 124359: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12435c: 85 c0 test %eax,%eax <== NOT EXECUTED 12435e: 0f 84 45 ff ff ff je 1242a9 <== 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; 124364: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 124367: 66 89 46 08 mov %ax,0x8(%esi) <== NOT EXECUTED pwd->pw_gid = pwgid; 12436b: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 12436e: 66 89 46 0a mov %ax,0xa(%esi) <== NOT EXECUTED 124372: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 124377: e9 2f ff ff ff jmp 1242ab <== NOT EXECUTED 0010b480 : #include int sched_get_priority_max( int policy ) { 10b480: 55 push %ebp <== NOT EXECUTED 10b481: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b483: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED switch ( policy ) { 10b486: 83 7d 08 03 cmpl $0x3,0x8(%ebp) <== NOT EXECUTED 10b48a: 76 14 jbe 10b4a0 <== NOT EXECUTED case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10b48c: e8 4f 71 00 00 call 1125e0 <__errno> <== NOT EXECUTED 10b491: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b497: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; } 10b49c: c9 leave <== NOT EXECUTED 10b49d: c3 ret <== NOT EXECUTED 10b49e: 66 90 xchg %ax,%ax <== NOT EXECUTED int sched_get_priority_max( int policy ) { switch ( policy ) { 10b4a0: b8 fe 00 00 00 mov $0xfe,%eax <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MAXIMUM_PRIORITY; } 10b4a5: c9 leave <== NOT EXECUTED 10b4a6: c3 ret <== NOT EXECUTED 0010b4a8 : #include int sched_get_priority_min( int policy ) { 10b4a8: 55 push %ebp <== NOT EXECUTED 10b4a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4ab: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED switch ( policy ) { 10b4ae: 83 7d 08 03 cmpl $0x3,0x8(%ebp) <== NOT EXECUTED 10b4b2: 76 14 jbe 10b4c8 <== NOT EXECUTED case SCHED_RR: case SCHED_SPORADIC: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 10b4b4: e8 27 71 00 00 call 1125e0 <__errno> <== NOT EXECUTED 10b4b9: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b4bf: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 10b4c4: c9 leave <== NOT EXECUTED 10b4c5: c3 ret <== NOT EXECUTED 10b4c6: 66 90 xchg %ax,%ax <== NOT EXECUTED int sched_get_priority_min( int policy ) { switch ( policy ) { 10b4c8: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( EINVAL ); } return POSIX_SCHEDULER_MINIMUM_PRIORITY; } 10b4cd: c9 leave <== NOT EXECUTED 10b4ce: c3 ret <== NOT EXECUTED 0010a44c : int sched_getparam( pid_t pid, const struct sched_param *param ) { 10a44c: 55 push %ebp <== NOT EXECUTED 10a44d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a44f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a452: e8 29 76 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a457: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a45d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a462: c9 leave <== NOT EXECUTED 10a463: c3 ret <== NOT EXECUTED 0010a464 : #include int sched_getscheduler( pid_t pid ) { 10a464: 55 push %ebp <== NOT EXECUTED 10a465: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a467: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a46a: e8 11 76 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a46f: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a475: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a47a: c9 leave <== NOT EXECUTED 10a47b: c3 ret <== NOT EXECUTED 0010b4d0 : int sched_rr_get_interval( pid_t pid, struct timespec *interval ) { 10b4d0: 55 push %ebp <== NOT EXECUTED 10b4d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4d3: 56 push %esi <== NOT EXECUTED 10b4d4: 53 push %ebx <== NOT EXECUTED 10b4d5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b4d8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10b4db: 85 db test %ebx,%ebx <== NOT EXECUTED 10b4dd: 75 21 jne 10b500 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ESRCH ); if ( !interval ) 10b4df: 85 f6 test %esi,%esi <== NOT EXECUTED 10b4e1: 74 38 je 10b51b <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval ); 10b4e3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b4e6: 56 push %esi <== NOT EXECUTED 10b4e7: ff 35 84 33 12 00 pushl 0x123384 <== NOT EXECUTED 10b4ed: e8 7a 37 00 00 call 10ec6c <_Timespec_From_ticks> <== NOT EXECUTED 10b4f2: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b4f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10b4f7: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b4fa: 5b pop %ebx <== NOT EXECUTED 10b4fb: 5e pop %esi <== NOT EXECUTED 10b4fc: c9 leave <== NOT EXECUTED 10b4fd: c3 ret <== NOT EXECUTED 10b4fe: 66 90 xchg %ax,%ax <== NOT EXECUTED { /* * Only supported for the "calling process" (i.e. this node). */ if ( pid && pid != getpid() ) 10b500: e8 07 cb ff ff call 10800c <== NOT EXECUTED 10b505: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10b507: 74 d6 je 10b4df <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ESRCH ); 10b509: e8 d2 70 00 00 call 1125e0 <__errno> <== NOT EXECUTED 10b50e: c7 00 03 00 00 00 movl $0x3,(%eax) <== NOT EXECUTED 10b514: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10b519: eb dc jmp 10b4f7 <== NOT EXECUTED if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 10b51b: e8 c0 70 00 00 call 1125e0 <__errno> <== NOT EXECUTED 10b520: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b526: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10b52b: eb ca jmp 10b4f7 <== NOT EXECUTED 0010a47c : int sched_setparam( pid_t pid, const struct sched_param *param ) { 10a47c: 55 push %ebp <== NOT EXECUTED 10a47d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a47f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a482: e8 f9 75 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a487: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a48d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a492: c9 leave <== NOT EXECUTED 10a493: c3 ret <== NOT EXECUTED 0010a494 : int sched_setscheduler( pid_t pid, int policy, const struct sched_param *param ) { 10a494: 55 push %ebp <== NOT EXECUTED 10a495: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a497: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a49a: e8 e1 75 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a49f: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a4a5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a4aa: c9 leave <== NOT EXECUTED 10a4ab: c3 ret <== NOT EXECUTED 0010b530 : #include #include #include int sched_yield( void ) { 10b530: 55 push %ebp <== NOT EXECUTED 10b531: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b533: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10b536: a1 b8 33 12 00 mov 0x1233b8,%eax <== NOT EXECUTED 10b53b: 40 inc %eax <== NOT EXECUTED 10b53c: a3 b8 33 12 00 mov %eax,0x1233b8 <== NOT EXECUTED _Thread_Disable_dispatch(); _Thread_Yield_processor(); 10b541: e8 86 36 00 00 call 10ebcc <_Thread_Yield_processor> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b546: e8 8d 2a 00 00 call 10dfd8 <_Thread_Enable_dispatch> <== NOT EXECUTED return 0; } 10b54b: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b54d: c9 leave <== NOT EXECUTED 10b54e: c3 ret <== NOT EXECUTED 0010a170 : void seekdir( DIR *dirp, long loc ) { 10a170: 55 push %ebp <== NOT EXECUTED 10a171: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a173: 53 push %ebx <== NOT EXECUTED 10a174: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a177: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED off_t status; if ( !dirp ) 10a17a: 85 db test %ebx,%ebx <== NOT EXECUTED 10a17c: 74 1a je 10a198 <== NOT EXECUTED return; status = lseek( dirp->dd_fd, loc, SEEK_SET ); 10a17e: 50 push %eax <== NOT EXECUTED 10a17f: 6a 00 push $0x0 <== NOT EXECUTED 10a181: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a184: ff 33 pushl (%ebx) <== NOT EXECUTED 10a186: e8 19 eb ff ff call 108ca4 <== NOT EXECUTED /* * This is not a nice way to error out, but we have no choice here. */ if ( status == -1 ) 10a18b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a18e: 40 inc %eax <== NOT EXECUTED 10a18f: 74 07 je 10a198 <== NOT EXECUTED return; dirp->dd_loc = 0; 10a191: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED } 10a198: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a19b: c9 leave <== NOT EXECUTED 10a19c: c3 ret <== NOT EXECUTED 0010c800 : */ int sem_close( sem_t *sem ) { 10c800: 55 push %ebp <== NOT EXECUTED 10c801: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c803: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, 10c806: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10c809: 50 push %eax <== NOT EXECUTED 10c80a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c80d: ff 30 pushl (%eax) <== NOT EXECUTED 10c80f: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 10c814: e8 07 23 00 00 call 10eb20 <_Objects_Get> <== NOT EXECUTED register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 10c819: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c81c: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10c81f: 85 d2 test %edx,%edx <== NOT EXECUTED 10c821: 74 15 je 10c838 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10c823: e8 60 7c 00 00 call 114488 <__errno> <== NOT EXECUTED 10c828: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c82e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 10c833: c9 leave <== NOT EXECUTED 10c834: c3 ret <== NOT EXECUTED 10c835: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: the_semaphore->open_count -= 1; 10c838: ff 48 18 decl 0x18(%eax) <== NOT EXECUTED _POSIX_Semaphore_Delete( the_semaphore ); 10c83b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c83e: 50 push %eax <== NOT EXECUTED 10c83f: e8 78 5f 00 00 call 1127bc <_POSIX_Semaphore_Delete> <== NOT EXECUTED _Thread_Enable_dispatch(); 10c844: e8 1b 2b 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c849: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c84b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10c84e: c9 leave <== NOT EXECUTED 10c84f: c3 ret <== NOT EXECUTED 0010c850 : */ int sem_destroy( sem_t *sem ) { 10c850: 55 push %ebp <== NOT EXECUTED 10c851: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c853: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10c856: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10c859: 50 push %eax <== NOT EXECUTED 10c85a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c85d: ff 30 pushl (%eax) <== NOT EXECUTED 10c85f: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 10c864: e8 b7 22 00 00 call 10eb20 <_Objects_Get> <== NOT EXECUTED register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 10c869: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c86c: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10c86f: 85 d2 test %edx,%edx <== NOT EXECUTED 10c871: 74 15 je 10c888 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10c873: e8 10 7c 00 00 call 114488 <__errno> <== NOT EXECUTED 10c878: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c87e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 10c883: c9 leave <== NOT EXECUTED 10c884: c3 ret <== NOT EXECUTED 10c885: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED case OBJECTS_LOCAL: /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == TRUE ) { 10c888: 80 78 14 00 cmpb $0x0,0x14(%eax) <== NOT EXECUTED 10c88c: 75 16 jne 10c8a4 <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( EINVAL ); } _POSIX_Semaphore_Delete( the_semaphore ); 10c88e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c891: 50 push %eax <== NOT EXECUTED 10c892: e8 25 5f 00 00 call 1127bc <_POSIX_Semaphore_Delete> <== NOT EXECUTED _Thread_Enable_dispatch(); 10c897: e8 c8 2a 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c89c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c89e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10c8a1: c9 leave <== NOT EXECUTED 10c8a2: c3 ret <== NOT EXECUTED 10c8a3: 90 nop <== NOT EXECUTED /* * Undefined operation on a named semaphore. */ if ( the_semaphore->named == TRUE ) { _Thread_Enable_dispatch(); 10c8a4: e8 bb 2a 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10c8a9: e8 da 7b 00 00 call 114488 <__errno> <== NOT EXECUTED 10c8ae: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c8b4: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10c8b9: c9 leave <== NOT EXECUTED 10c8ba: c3 ret <== NOT EXECUTED 0010c8bc : int sem_getvalue( sem_t *sem, int *sval ) { 10c8bc: 55 push %ebp <== NOT EXECUTED 10c8bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c8bf: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10c8c2: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10c8c5: 50 push %eax <== NOT EXECUTED 10c8c6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c8c9: ff 30 pushl (%eax) <== NOT EXECUTED 10c8cb: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 10c8d0: e8 4b 22 00 00 call 10eb20 <_Objects_Get> <== NOT EXECUTED register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 10c8d5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c8d8: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10c8db: 85 d2 test %edx,%edx <== NOT EXECUTED 10c8dd: 74 15 je 10c8f4 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10c8df: e8 a4 7b 00 00 call 114488 <__errno> <== NOT EXECUTED 10c8e4: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c8ea: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 10c8ef: c9 leave <== NOT EXECUTED 10c8f0: c3 ret <== NOT EXECUTED 10c8f1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore ); 10c8f4: 8b 40 64 mov 0x64(%eax),%eax <== NOT EXECUTED 10c8f7: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c8fa: 89 02 mov %eax,(%edx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10c8fc: e8 63 2a 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c901: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10c903: c9 leave <== NOT EXECUTED 10c904: c3 ret <== NOT EXECUTED 0010c908 : int sem_init( sem_t *sem, int pshared, unsigned int value ) { 10c908: 55 push %ebp <== NOT EXECUTED 10c909: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c90b: 53 push %ebx <== NOT EXECUTED 10c90c: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10c90f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED int status; POSIX_Semaphore_Control *the_semaphore; if ( !sem ) 10c912: 85 db test %ebx,%ebx <== NOT EXECUTED 10c914: 74 2a je 10c940 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); status = _POSIX_Semaphore_Create_support( 10c916: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10c919: 50 push %eax <== NOT EXECUTED 10c91a: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10c91d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c920: 6a 00 push $0x0 <== NOT EXECUTED 10c922: e8 7d 5d 00 00 call 1126a4 <_POSIX_Semaphore_Create_support> <== NOT EXECUTED 10c927: 89 c2 mov %eax,%edx <== NOT EXECUTED pshared, value, &the_semaphore ); if ( status != -1 ) 10c929: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c92c: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10c92f: 74 08 je 10c939 <== NOT EXECUTED *sem = the_semaphore->Object.id; 10c931: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10c934: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10c937: 89 03 mov %eax,(%ebx) <== NOT EXECUTED return status; } 10c939: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c93b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c93e: c9 leave <== NOT EXECUTED 10c93f: c3 ret <== NOT EXECUTED { int status; POSIX_Semaphore_Control *the_semaphore; if ( !sem ) rtems_set_errno_and_return_minus_one( EINVAL ); 10c940: e8 43 7b 00 00 call 114488 <__errno> <== NOT EXECUTED 10c945: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c94b: ba ff ff ff ff mov $0xffffffff,%edx <== NOT EXECUTED 10c950: eb e7 jmp 10c939 <== NOT EXECUTED 0010c954 : int oflag, ... /* mode_t mode, */ /* unsigned int value */ ) { 10c954: 55 push %ebp <== NOT EXECUTED 10c955: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c957: 57 push %edi <== NOT EXECUTED 10c958: 56 push %esi <== NOT EXECUTED 10c959: 53 push %ebx <== NOT EXECUTED 10c95a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10c95d: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10c960: a1 d8 58 12 00 mov 0x1258d8,%eax <== NOT EXECUTED 10c965: 40 inc %eax <== NOT EXECUTED 10c966: a3 d8 58 12 00 mov %eax,0x1258d8 <== NOT EXECUTED POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; _Thread_Disable_dispatch(); if ( oflag & O_CREAT ) { 10c96b: 89 f7 mov %esi,%edi <== NOT EXECUTED 10c96d: 81 e7 00 02 00 00 and $0x200,%edi <== NOT EXECUTED 10c973: 0f 85 8b 00 00 00 jne 10ca04 <== NOT EXECUTED 10c979: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 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 ); 10c980: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c983: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c986: 50 push %eax <== NOT EXECUTED 10c987: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c98a: e8 7d 5e 00 00 call 11280c <_POSIX_Semaphore_Name_to_id> <== NOT EXECUTED 10c98f: 89 c3 mov %eax,%ebx <== NOT EXECUTED * 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 ) { 10c991: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c994: 85 c0 test %eax,%eax <== NOT EXECUTED 10c996: 74 28 je 10c9c0 <== 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) ) ) { 10c998: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10c99b: 75 08 jne 10c9a5 <== NOT EXECUTED 10c99d: 85 ff test %edi,%edi <== NOT EXECUTED 10c99f: 0f 85 8b 00 00 00 jne 10ca30 <== NOT EXECUTED _Thread_Enable_dispatch(); 10c9a5: e8 ba 29 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one_cast( status, sem_t * ); 10c9aa: e8 d9 7a 00 00 call 114488 <__errno> <== NOT EXECUTED 10c9af: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10c9b1: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED if ( status == -1 ) return SEM_FAILED; id = &the_semaphore->Object.id; return (sem_t *)id; } 10c9b6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c9b9: 5b pop %ebx <== NOT EXECUTED 10c9ba: 5e pop %esi <== NOT EXECUTED 10c9bb: 5f pop %edi <== NOT EXECUTED 10c9bc: c9 leave <== NOT EXECUTED 10c9bd: c3 ret <== NOT EXECUTED 10c9be: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { 10c9c0: 81 e6 00 0a 00 00 and $0xa00,%esi <== NOT EXECUTED 10c9c6: 81 fe 00 0a 00 00 cmp $0xa00,%esi <== NOT EXECUTED 10c9cc: 74 42 je 10ca10 <== NOT EXECUTED * to add to the heap * @param[in] size is the size in bytes of the memory area to add * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, 10c9ce: 50 push %eax <== NOT EXECUTED 10c9cf: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10c9d2: 50 push %eax <== NOT EXECUTED 10c9d3: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10c9d6: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 10c9db: e8 40 21 00 00 call 10eb20 <_Objects_Get> <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); } the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location ); 10c9e0: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED the_semaphore->open_count += 1; 10c9e3: ff 40 18 incl 0x18(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10c9e6: e8 79 29 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED _Thread_Enable_dispatch(); 10c9eb: e8 74 29 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED id = &the_semaphore->Object.id; return (sem_t *)id; 10c9f0: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10c9f3: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 10c9f6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( status == -1 ) return SEM_FAILED; id = &the_semaphore->Object.id; return (sem_t *)id; } 10c9f9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c9fc: 5b pop %ebx <== NOT EXECUTED 10c9fd: 5e pop %esi <== NOT EXECUTED 10c9fe: 5f pop %edi <== NOT EXECUTED 10c9ff: c9 leave <== NOT EXECUTED 10ca00: c3 ret <== NOT EXECUTED 10ca01: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _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 ); 10ca04: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10ca07: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10ca0a: e9 71 ff ff ff jmp 10c980 <== NOT EXECUTED 10ca0f: 90 nop <== NOT EXECUTED /* * Check for existence with creation. */ if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) { _Thread_Enable_dispatch(); 10ca10: e8 4f 29 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * ); 10ca15: e8 6e 7a 00 00 call 114488 <__errno> <== NOT EXECUTED 10ca1a: c7 00 11 00 00 00 movl $0x11,(%eax) <== NOT EXECUTED 10ca20: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED if ( status == -1 ) return SEM_FAILED; id = &the_semaphore->Object.id; return (sem_t *)id; } 10ca25: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ca28: 5b pop %ebx <== NOT EXECUTED 10ca29: 5e pop %esi <== NOT EXECUTED 10ca2a: 5f pop %edi <== NOT EXECUTED 10ca2b: c9 leave <== NOT EXECUTED 10ca2c: c3 ret <== NOT EXECUTED 10ca2d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * 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( 10ca30: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10ca33: 50 push %eax <== NOT EXECUTED 10ca34: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10ca37: 6a 00 push $0x0 <== NOT EXECUTED 10ca39: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ca3c: e8 63 5c 00 00 call 1126a4 <_POSIX_Semaphore_Create_support> <== NOT EXECUTED 10ca41: 89 c3 mov %eax,%ebx <== NOT EXECUTED /* * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); 10ca43: e8 1c 29 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED if ( status == -1 ) 10ca48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ca4b: 43 inc %ebx <== NOT EXECUTED 10ca4c: 74 0a je 10ca58 <== NOT EXECUTED return SEM_FAILED; id = &the_semaphore->Object.id; return (sem_t *)id; 10ca4e: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10ca51: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 10ca54: eb a3 jmp 10c9f9 <== NOT EXECUTED 10ca56: 66 90 xchg %ax,%ax <== NOT EXECUTED * errno was set by Create_support, so don't set it again. */ _Thread_Enable_dispatch(); if ( status == -1 ) 10ca58: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ca5d: eb 9a jmp 10c9f9 <== NOT EXECUTED 0010ca60 : */ int sem_post( sem_t *sem ) { 10ca60: 55 push %ebp <== NOT EXECUTED 10ca61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca63: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10ca66: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10ca69: 50 push %eax <== NOT EXECUTED 10ca6a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ca6d: ff 30 pushl (%eax) <== NOT EXECUTED 10ca6f: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 10ca74: e8 a7 20 00 00 call 10eb20 <_Objects_Get> <== NOT EXECUTED register POSIX_Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { 10ca79: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ca7c: 8b 4d fc mov -0x4(%ebp),%ecx <== NOT EXECUTED 10ca7f: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ca81: 74 15 je 10ca98 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10ca83: e8 00 7a 00 00 call 114488 <__errno> <== NOT EXECUTED 10ca88: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10ca8e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 10ca93: c9 leave <== NOT EXECUTED 10ca94: c3 ret <== NOT EXECUTED 10ca95: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_semaphore = _POSIX_Semaphore_Get( sem, &location ); switch ( location ) { case OBJECTS_LOCAL: _CORE_semaphore_Surrender( 10ca98: 52 push %edx <== NOT EXECUTED 10ca99: 6a 00 push $0x0 <== NOT EXECUTED 10ca9b: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10ca9e: 83 c0 1c add $0x1c,%eax <== NOT EXECUTED 10caa1: 50 push %eax <== NOT EXECUTED 10caa2: e8 cd 17 00 00 call 10e274 <_CORE_semaphore_Surrender> <== NOT EXECUTED NULL /* XXX need to define a routine to handle this case */ #else NULL #endif ); _Thread_Enable_dispatch(); 10caa7: e8 b8 28 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED 10caac: 31 c0 xor %eax,%eax <== NOT EXECUTED 10caae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10cab1: c9 leave <== NOT EXECUTED 10cab2: c3 ret <== NOT EXECUTED 0010cab4 : int sem_timedwait( sem_t *sem, const struct timespec *abstime ) { 10cab4: 55 push %ebp <== NOT EXECUTED 10cab5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cab7: 53 push %ebx <== NOT EXECUTED 10cab8: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10cabb: 8b 5d 08 mov 0x8(%ebp),%ebx <== 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. */ status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks ); 10cabe: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10cac1: 50 push %eax <== NOT EXECUTED 10cac2: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10cac5: e8 b2 52 00 00 call 111d7c <_POSIX_Absolute_timeout_to_ticks> <== NOT EXECUTED switch ( status ) { 10caca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cacd: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10cad0: 76 16 jbe 10cae8 <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = true; break; } lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 10cad2: 52 push %edx <== NOT EXECUTED 10cad3: ff 75 f8 pushl -0x8(%ebp) <== NOT EXECUTED 10cad6: 6a 01 push $0x1 <== NOT EXECUTED 10cad8: 53 push %ebx <== NOT EXECUTED 10cad9: e8 92 5d 00 00 call 112870 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED 10cade: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } } return lock_status; } 10cae1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cae4: c9 leave <== NOT EXECUTED 10cae5: c3 ret <== NOT EXECUTED 10cae6: 66 90 xchg %ax,%ax <== NOT EXECUTED case POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE: do_wait = true; break; } lock_status = _POSIX_Semaphore_Wait_support( sem, do_wait, ticks ); 10cae8: 50 push %eax <== NOT EXECUTED 10cae9: ff 75 f8 pushl -0x8(%ebp) <== NOT EXECUTED 10caec: 6a 00 push $0x0 <== NOT EXECUTED 10caee: 53 push %ebx <== NOT EXECUTED 10caef: e8 7c 5d 00 00 call 112870 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED 10caf4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } } return lock_status; } 10caf7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cafa: c9 leave <== NOT EXECUTED 10cafb: c3 ret <== NOT EXECUTED 0010cafc : */ int sem_trywait( sem_t *sem ) { 10cafc: 55 push %ebp <== NOT EXECUTED 10cafd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10caff: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return _POSIX_Semaphore_Wait_support(sem, FALSE, THREAD_QUEUE_WAIT_FOREVER); 10cb02: 6a 00 push $0x0 <== NOT EXECUTED 10cb04: 6a 00 push $0x0 <== NOT EXECUTED 10cb06: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cb09: e8 62 5d 00 00 call 112870 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED } 10cb0e: c9 leave <== NOT EXECUTED 10cb0f: c3 ret <== NOT EXECUTED 0010cb10 : */ int sem_unlink( const char *name ) { 10cb10: 55 push %ebp <== NOT EXECUTED 10cb11: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb13: 53 push %ebx <== NOT EXECUTED 10cb14: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10cb17: a1 d8 58 12 00 mov 0x1258d8,%eax <== NOT EXECUTED 10cb1c: 40 inc %eax <== NOT EXECUTED 10cb1d: a3 d8 58 12 00 mov %eax,0x1258d8 <== NOT EXECUTED register POSIX_Semaphore_Control *the_semaphore; sem_t the_semaphore_id; _Thread_Disable_dispatch(); status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); 10cb22: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10cb25: 50 push %eax <== NOT EXECUTED 10cb26: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cb29: e8 de 5c 00 00 call 11280c <_POSIX_Semaphore_Name_to_id> <== NOT EXECUTED 10cb2e: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( status != 0 ) { 10cb30: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cb33: 85 c0 test %eax,%eax <== NOT EXECUTED 10cb35: 75 45 jne 10cb7c <== NOT EXECUTED _Thread_Enable_dispatch(); rtems_set_errno_and_return_minus_one( status ); } the_semaphore = (POSIX_Semaphore_Control *) _Objects_Get_local_object( 10cb37: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 10cb3a: 66 3b 05 30 5c 12 00 cmp 0x125c30,%ax <== NOT EXECUTED 10cb41: 77 35 ja 10cb78 <== NOT EXECUTED 10cb43: 0f b7 d0 movzwl %ax,%edx <== NOT EXECUTED 10cb46: a1 3c 5c 12 00 mov 0x125c3c,%eax <== NOT EXECUTED 10cb4b: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED &_POSIX_Semaphore_Information, _Objects_Get_index( the_semaphore_id ) ); the_semaphore->linked = FALSE; 10cb4e: c6 43 15 00 movb $0x0,0x15(%ebx) <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10cb52: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cb55: 53 push %ebx <== NOT EXECUTED 10cb56: 68 20 5c 12 00 push $0x125c20 <== NOT EXECUTED 10cb5b: e8 e4 20 00 00 call 10ec44 <_Objects_Namespace_remove> <== NOT EXECUTED _POSIX_Semaphore_Namespace_remove( the_semaphore ); _POSIX_Semaphore_Delete( the_semaphore ); 10cb60: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10cb63: e8 54 5c 00 00 call 1127bc <_POSIX_Semaphore_Delete> <== NOT EXECUTED _Thread_Enable_dispatch(); 10cb68: e8 f7 27 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED 10cb6d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cb6f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10cb72: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cb75: c9 leave <== NOT EXECUTED 10cb76: c3 ret <== NOT EXECUTED 10cb77: 90 nop <== NOT EXECUTED bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 10cb78: 31 db xor %ebx,%ebx <== NOT EXECUTED 10cb7a: eb d2 jmp 10cb4e <== NOT EXECUTED _Thread_Disable_dispatch(); status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id ); if ( status != 0 ) { _Thread_Enable_dispatch(); 10cb7c: e8 e3 27 00 00 call 10f364 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( status ); 10cb81: e8 02 79 00 00 call 114488 <__errno> <== NOT EXECUTED 10cb86: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10cb88: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10cb8d: eb e3 jmp 10cb72 <== NOT EXECUTED 0010cb90 : */ int sem_wait( sem_t *sem ) { 10cb90: 55 push %ebp <== NOT EXECUTED 10cb91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb93: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return _POSIX_Semaphore_Wait_support( sem, TRUE, THREAD_QUEUE_WAIT_FOREVER ); 10cb96: 6a 00 push $0x0 <== NOT EXECUTED 10cb98: 6a 01 push $0x1 <== NOT EXECUTED 10cb9a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cb9d: e8 ce 5c 00 00 call 112870 <_POSIX_Semaphore_Wait_support> <== NOT EXECUTED } 10cba2: c9 leave <== NOT EXECUTED 10cba3: c3 ret <== NOT EXECUTED 00123f70 : */ int setgid( gid_t gid ) { 123f70: 55 push %ebp <== NOT EXECUTED 123f71: 89 e5 mov %esp,%ebp <== NOT EXECUTED _POSIX_types_Gid = gid; 123f73: 8b 15 ec ba 14 00 mov 0x14baec,%edx <== NOT EXECUTED 123f79: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 123f7c: 66 89 42 2c mov %ax,0x2c(%edx) <== NOT EXECUTED return 0; } 123f80: 31 c0 xor %eax,%eax <== NOT EXECUTED 123f82: c9 leave <== NOT EXECUTED 123f83: c3 ret <== NOT EXECUTED 001244b4 : return NULL; return &grent; } void setgrent(void) { 1244b4: 55 push %ebp <== NOT EXECUTED 1244b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1244b7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED init_etc_passwd_group(); 1244ba: e8 f5 fe ff ff call 1243b4 <== NOT EXECUTED if (group_fp != NULL) 1244bf: a1 64 14 16 00 mov 0x161464,%eax <== NOT EXECUTED 1244c4: 85 c0 test %eax,%eax <== NOT EXECUTED 1244c6: 74 0c je 1244d4 <== NOT EXECUTED fclose(group_fp); 1244c8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1244cb: 50 push %eax <== NOT EXECUTED 1244cc: e8 cf d4 00 00 call 1319a0 <== NOT EXECUTED 1244d1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED group_fp = fopen("/etc/group", "r"); 1244d4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1244d7: 68 81 29 14 00 push $0x142981 <== NOT EXECUTED 1244dc: 68 59 50 14 00 push $0x145059 <== NOT EXECUTED 1244e1: e8 26 dc 00 00 call 13210c <== NOT EXECUTED 1244e6: a3 64 14 16 00 mov %eax,0x161464 <== NOT EXECUTED 1244eb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1244ee: c9 leave <== NOT EXECUTED 1244ef: c3 ret <== NOT EXECUTED 0012467c : return NULL; return &pwent; } void setpwent(void) { 12467c: 55 push %ebp <== NOT EXECUTED 12467d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12467f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED init_etc_passwd_group(); 124682: e8 2d fd ff ff call 1243b4 <== NOT EXECUTED if (passwd_fp != NULL) 124687: a1 64 13 16 00 mov 0x161364,%eax <== NOT EXECUTED 12468c: 85 c0 test %eax,%eax <== NOT EXECUTED 12468e: 74 0c je 12469c <== NOT EXECUTED fclose(passwd_fp); 124690: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124693: 50 push %eax <== NOT EXECUTED 124694: e8 07 d3 00 00 call 1319a0 <== NOT EXECUTED 124699: 83 c4 10 add $0x10,%esp <== NOT EXECUTED passwd_fp = fopen("/etc/passwd", "r"); 12469c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12469f: 68 81 29 14 00 push $0x142981 <== NOT EXECUTED 1246a4: 68 4d 50 14 00 push $0x14504d <== NOT EXECUTED 1246a9: e8 5e da 00 00 call 13210c <== NOT EXECUTED 1246ae: a3 64 13 16 00 mov %eax,0x161364 <== NOT EXECUTED 1246b3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1246b6: c9 leave <== NOT EXECUTED 1246b7: c3 ret <== NOT EXECUTED 0010b474 : */ int setuid( uid_t uid ) { 10b474: 55 push %ebp <== NOT EXECUTED 10b475: 89 e5 mov %esp,%ebp <== NOT EXECUTED _POSIX_types_Uid = uid; 10b477: 8b 15 ec ba 14 00 mov 0x14baec,%edx <== NOT EXECUTED 10b47d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b480: 66 89 42 2a mov %ax,0x2a(%edx) <== NOT EXECUTED return 0; } 10b484: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b486: c9 leave <== NOT EXECUTED 10b487: c3 ret <== NOT EXECUTED 0010a990 : int sigaction( int sig, const struct sigaction *act, struct sigaction *oact ) { 10a990: 55 push %ebp <== NOT EXECUTED 10a991: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a993: 57 push %edi <== NOT EXECUTED 10a994: 56 push %esi <== NOT EXECUTED 10a995: 53 push %ebx <== NOT EXECUTED 10a996: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a999: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10a99c: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED ISR_Level level; if ( oact ) 10a99f: 85 ff test %edi,%edi <== NOT EXECUTED 10a9a1: 74 11 je 10a9b4 <== NOT EXECUTED *oact = _POSIX_signals_Vectors[ sig ]; 10a9a3: 8d 04 5b lea (%ebx,%ebx,2),%eax <== NOT EXECUTED 10a9a6: 8d 34 85 a0 29 12 00 lea 0x1229a0(,%eax,4),%esi <== NOT EXECUTED 10a9ad: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10a9b2: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !sig ) 10a9b4: 85 db test %ebx,%ebx <== NOT EXECUTED 10a9b6: 74 74 je 10aa2c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(sig) ) 10a9b8: 8d 4b ff lea -0x1(%ebx),%ecx <== NOT EXECUTED 10a9bb: 83 f9 1f cmp $0x1f,%ecx <== NOT EXECUTED 10a9be: 77 6c ja 10aa2c <== NOT EXECUTED * * NOTE: Solaris documentation claims to "silently enforce" this which * contradicts the POSIX specification. */ if ( sig == SIGKILL ) 10a9c0: 83 fb 09 cmp $0x9,%ebx <== NOT EXECUTED 10a9c3: 74 67 je 10aa2c <== NOT EXECUTED /* * Evaluate the new action structure and set the global signal vector * appropriately. */ if ( act ) { 10a9c5: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10a9c8: 85 d2 test %edx,%edx <== NOT EXECUTED 10a9ca: 74 3a je 10aa06 <== NOT EXECUTED /* * Unless the user is installing the default signal actions, then * we can just copy the provided sigaction structure into the vectors. */ _ISR_Disable( level ); 10a9cc: 9c pushf <== NOT EXECUTED 10a9cd: fa cli <== NOT EXECUTED 10a9ce: 8f 45 f0 popl -0x10(%ebp) <== NOT EXECUTED if ( act->sa_handler == SIG_DFL ) { 10a9d1: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a9d4: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10a9d7: 85 c0 test %eax,%eax <== NOT EXECUTED 10a9d9: 74 35 je 10aa10 <== NOT EXECUTED _POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ]; } else { _POSIX_signals_Clear_process_signals( signo_to_mask(sig) ); 10a9db: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a9de: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10a9e3: d3 e0 shl %cl,%eax <== NOT EXECUTED 10a9e5: 50 push %eax <== NOT EXECUTED 10a9e6: e8 85 56 00 00 call 110070 <_POSIX_signals_Clear_process_signals> <== NOT EXECUTED _POSIX_signals_Vectors[ sig ] = *act; 10a9eb: 8d 04 5b lea (%ebx,%ebx,2),%eax <== NOT EXECUTED 10a9ee: 8d 3c 85 a0 29 12 00 lea 0x1229a0(,%eax,4),%edi <== NOT EXECUTED 10a9f5: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10a9fa: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10a9fd: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10a9ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _ISR_Enable( level ); 10aa02: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10aa05: 9d popf <== NOT EXECUTED 10aa06: 31 c0 xor %eax,%eax <== NOT EXECUTED * + If we are now ignoring a signal that was previously pending, * we clear the pending signal indicator. */ return 0; } 10aa08: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aa0b: 5b pop %ebx <== NOT EXECUTED 10aa0c: 5e pop %esi <== NOT EXECUTED 10aa0d: 5f pop %edi <== NOT EXECUTED 10aa0e: c9 leave <== NOT EXECUTED 10aa0f: c3 ret <== NOT EXECUTED * 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 ]; 10aa10: 8d 04 5b lea (%ebx,%ebx,2),%eax <== NOT EXECUTED 10aa13: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10aa16: 8d b8 a0 29 12 00 lea 0x1229a0(%eax),%edi <== NOT EXECUTED 10aa1c: 8d b0 20 bf 11 00 lea 0x11bf20(%eax),%esi <== NOT EXECUTED 10aa22: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10aa27: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10aa29: eb d7 jmp 10aa02 <== NOT EXECUTED 10aa2b: 90 nop <== 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 ); 10aa2c: e8 9b 72 00 00 call 111ccc <__errno> <== NOT EXECUTED 10aa31: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10aa37: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10aa3c: eb ca jmp 10aa08 <== NOT EXECUTED 0010aa40 : int sigaddset( sigset_t *set, int signo ) { 10aa40: 55 push %ebp <== NOT EXECUTED 10aa41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa43: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10aa46: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10aa49: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED if ( !set ) 10aa4c: 85 d2 test %edx,%edx <== NOT EXECUTED 10aa4e: 74 1c je 10aa6c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !signo ) 10aa50: 85 c0 test %eax,%eax <== NOT EXECUTED 10aa52: 74 18 je 10aa6c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(signo) ) 10aa54: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 10aa57: 83 f9 1f cmp $0x1f,%ecx <== NOT EXECUTED 10aa5a: 77 10 ja 10aa6c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); *set |= signo_to_mask(signo); 10aa5c: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10aa61: d3 e0 shl %cl,%eax <== NOT EXECUTED 10aa63: 09 02 or %eax,(%edx) <== NOT EXECUTED 10aa65: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10aa67: c9 leave <== NOT EXECUTED 10aa68: c3 ret <== NOT EXECUTED 10aa69: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !signo ) rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(signo) ) rtems_set_errno_and_return_minus_one( EINVAL ); 10aa6c: e8 5b 72 00 00 call 111ccc <__errno> <== NOT EXECUTED 10aa71: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10aa77: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED *set |= signo_to_mask(signo); return 0; } 10aa7c: c9 leave <== NOT EXECUTED 10aa7d: c3 ret <== NOT EXECUTED 0010c748 : int sigdelset( sigset_t *set, int signo ) { 10c748: 55 push %ebp <== NOT EXECUTED 10c749: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c74b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c74e: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c751: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED if ( !set ) 10c754: 85 d2 test %edx,%edx <== NOT EXECUTED 10c756: 74 1c je 10c774 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !signo ) 10c758: 85 c0 test %eax,%eax <== NOT EXECUTED 10c75a: 74 13 je 10c76f <== NOT EXECUTED return 0; if ( !is_valid_signo(signo) ) 10c75c: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 10c75f: 83 f9 1f cmp $0x1f,%ecx <== NOT EXECUTED 10c762: 77 10 ja 10c774 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); *set &= ~signo_to_mask(signo); 10c764: b8 fe ff ff ff mov $0xfffffffe,%eax <== NOT EXECUTED 10c769: d3 c0 rol %cl,%eax <== NOT EXECUTED 10c76b: 21 02 and %eax,(%edx) <== NOT EXECUTED 10c76d: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10c76f: c9 leave <== NOT EXECUTED 10c770: c3 ret <== NOT EXECUTED 10c771: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !signo ) return 0; if ( !is_valid_signo(signo) ) rtems_set_errno_and_return_minus_one( EINVAL ); 10c774: e8 43 78 00 00 call 113fbc <__errno> <== NOT EXECUTED 10c779: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c77f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED *set &= ~signo_to_mask(signo); return 0; } 10c784: c9 leave <== NOT EXECUTED 10c785: c3 ret <== NOT EXECUTED 0010f264 : #include int sigemptyset( sigset_t *set ) { 10f264: 55 push %ebp <== NOT EXECUTED 10f265: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f267: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f26a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !set ) 10f26d: 85 c0 test %eax,%eax <== NOT EXECUTED 10f26f: 74 0a je 10f27b <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); *set = 0; 10f271: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 10f277: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10f279: c9 leave <== NOT EXECUTED 10f27a: c3 ret <== NOT EXECUTED int sigemptyset( sigset_t *set ) { if ( !set ) rtems_set_errno_and_return_minus_one( EINVAL ); 10f27b: e8 00 1a 00 00 call 110c80 <__errno> <== NOT EXECUTED 10f280: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10f286: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED *set = 0; return 0; } 10f28b: c9 leave <== NOT EXECUTED 10f28c: c3 ret <== NOT EXECUTED 0010c7b4 : #include int sigfillset( sigset_t *set ) { 10c7b4: 55 push %ebp <== NOT EXECUTED 10c7b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c7b7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c7ba: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !set ) 10c7bd: 85 c0 test %eax,%eax <== NOT EXECUTED 10c7bf: 74 0a je 10c7cb <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); *set = SIGNAL_ALL_MASK; 10c7c1: c7 00 ff ff ff ff movl $0xffffffff,(%eax) <== NOT EXECUTED 10c7c7: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10c7c9: c9 leave <== NOT EXECUTED 10c7ca: c3 ret <== NOT EXECUTED int sigfillset( sigset_t *set ) { if ( !set ) rtems_set_errno_and_return_minus_one( EINVAL ); 10c7cb: e8 ec 77 00 00 call 113fbc <__errno> <== NOT EXECUTED 10c7d0: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c7d6: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED *set = SIGNAL_ALL_MASK; return 0; } 10c7db: c9 leave <== NOT EXECUTED 10c7dc: c3 ret <== NOT EXECUTED 0010c7e0 : int sigismember( const sigset_t *set, int signo ) { 10c7e0: 55 push %ebp <== NOT EXECUTED 10c7e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c7e3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c7e6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c7e9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED if ( !set ) 10c7ec: 85 d2 test %edx,%edx <== NOT EXECUTED 10c7ee: 74 20 je 10c810 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !signo ) 10c7f0: 85 c0 test %eax,%eax <== NOT EXECUTED 10c7f2: 74 17 je 10c80b <== NOT EXECUTED return 0; if ( !is_valid_signo(signo) ) 10c7f4: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED 10c7f7: 83 f9 1f cmp $0x1f,%ecx <== NOT EXECUTED 10c7fa: 77 14 ja 10c810 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 10c7fc: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10c801: d3 e0 shl %cl,%eax <== NOT EXECUTED 10c803: 85 02 test %eax,(%edx) <== NOT EXECUTED 10c805: 0f 95 c0 setne %al <== NOT EXECUTED 10c808: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED if ( *set & signo_to_mask(signo) ) return 1; return 0; } 10c80b: c9 leave <== NOT EXECUTED 10c80c: c3 ret <== NOT EXECUTED 10c80d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !signo ) return 0; if ( !is_valid_signo(signo) ) rtems_set_errno_and_return_minus_one( EINVAL ); 10c810: e8 a7 77 00 00 call 113fbc <__errno> <== NOT EXECUTED 10c815: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10c81b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED if ( *set & signo_to_mask(signo) ) return 1; return 0; } 10c820: c9 leave <== NOT EXECUTED 10c821: c3 ret <== NOT EXECUTED 0010a5c0 : sighandler_t signal( int signum, sighandler_t handler ) { 10a5c0: 55 push %ebp <== NOT EXECUTED 10a5c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a5c3: 53 push %ebx <== NOT EXECUTED 10a5c4: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED struct sigaction s; struct sigaction old; s.sa_handler = handler ; 10a5c7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10a5ca: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED sigemptyset(&s.sa_mask); 10a5cd: 8d 5d f0 lea -0x10(%ebp),%ebx <== NOT EXECUTED 10a5d0: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10a5d3: 50 push %eax <== NOT EXECUTED 10a5d4: e8 bb ff ff ff call 10a594 <== NOT EXECUTED s.sa_flags = SA_RESTART | SA_INTERRUPT | SA_NOMASK; s.sa_restorer= NULL ; #elif defined(signal_like_SVR4) s.sa_flags = SA_RESTART; #else s.sa_flags = 0; 10a5d9: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED #endif sigaction( signum, &s, &old ); 10a5e0: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10a5e3: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10a5e6: 50 push %eax <== NOT EXECUTED 10a5e7: 53 push %ebx <== NOT EXECUTED 10a5e8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a5eb: e8 b4 fe ff ff call 10a4a4 <== NOT EXECUTED 10a5f0: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED return (sighandler_t) old.sa_handler; } 10a5f3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a5f6: c9 leave <== NOT EXECUTED 10a5f7: c3 ret <== NOT EXECUTED 0010aaac : #include int sigpending( sigset_t *set ) { 10aaac: 55 push %ebp <== NOT EXECUTED 10aaad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aaaf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10aab2: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED POSIX_API_Control *api; if ( !set ) 10aab5: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10aab7: 74 1c je 10aad5 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; *set = api->signals_pending | _POSIX_signals_Pending; 10aab9: a1 1c 24 12 00 mov 0x12241c,%eax <== NOT EXECUTED 10aabe: 8b 90 f8 00 00 00 mov 0xf8(%eax),%edx <== NOT EXECUTED 10aac4: a1 80 2b 12 00 mov 0x122b80,%eax <== NOT EXECUTED 10aac9: 0b 82 c8 00 00 00 or 0xc8(%edx),%eax <== NOT EXECUTED 10aacf: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10aad1: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10aad3: c9 leave <== NOT EXECUTED 10aad4: c3 ret <== NOT EXECUTED ) { POSIX_API_Control *api; if ( !set ) rtems_set_errno_and_return_minus_one( EINVAL ); 10aad5: e8 f2 71 00 00 call 111ccc <__errno> <== NOT EXECUTED 10aada: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10aae0: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; *set = api->signals_pending | _POSIX_signals_Pending; return 0; } 10aae5: c9 leave <== NOT EXECUTED 10aae6: c3 ret <== NOT EXECUTED 0010aae8 : int sigprocmask( int how, const sigset_t *set, sigset_t *oset ) { 10aae8: 55 push %ebp <== NOT EXECUTED 10aae9: 89 e5 mov %esp,%ebp <== NOT EXECUTED /* * P1003.1c/Draft 10, p. 38 maps sigprocmask to pthread_sigmask. */ return pthread_sigmask( how, set, oset ); } 10aaeb: c9 leave <== NOT EXECUTED { /* * P1003.1c/Draft 10, p. 38 maps sigprocmask to pthread_sigmask. */ return pthread_sigmask( how, set, oset ); 10aaec: e9 53 59 00 00 jmp 110444 <== NOT EXECUTED 0010c86c : int sigqueue( pid_t pid, int signo, const union sigval value ) { 10c86c: 55 push %ebp <== NOT EXECUTED 10c86d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c86f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return killinfo( pid, signo, &value ); 10c872: 8d 45 10 lea 0x10(%ebp),%eax <== NOT EXECUTED 10c875: 50 push %eax <== NOT EXECUTED 10c876: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c879: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c87c: e8 bf 56 00 00 call 111f40 <== NOT EXECUTED } 10c881: c9 leave <== NOT EXECUTED 10c882: c3 ret <== NOT EXECUTED 0010c884 : #include int sigsuspend( const sigset_t *sigmask ) { 10c884: 55 push %ebp <== NOT EXECUTED 10c885: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c887: 56 push %esi <== NOT EXECUTED 10c888: 53 push %ebx <== NOT EXECUTED 10c889: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED int status; POSIX_API_Control *api; api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ]; status = sigprocmask( SIG_BLOCK, sigmask, &saved_signals_blocked ); 10c88c: 8d 5d f4 lea -0xc(%ebp),%ebx <== NOT EXECUTED 10c88f: 53 push %ebx <== NOT EXECUTED 10c890: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c893: 6a 01 push $0x1 <== NOT EXECUTED 10c895: e8 c6 ff ff ff call 10c860 <== NOT EXECUTED (void) sigfillset( &all_signals ); 10c89a: 8d 75 f0 lea -0x10(%ebp),%esi <== NOT EXECUTED 10c89d: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10c8a0: e8 0f ff ff ff call 10c7b4 <== NOT EXECUTED status = sigtimedwait( &all_signals, NULL, NULL ); 10c8a5: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c8a8: 6a 00 push $0x0 <== NOT EXECUTED 10c8aa: 6a 00 push $0x0 <== NOT EXECUTED 10c8ac: 56 push %esi <== NOT EXECUTED 10c8ad: e8 7e 00 00 00 call 10c930 <== NOT EXECUTED 10c8b2: 89 c6 mov %eax,%esi <== NOT EXECUTED (void) sigprocmask( SIG_SETMASK, &saved_signals_blocked, NULL ); 10c8b4: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c8b7: 6a 00 push $0x0 <== NOT EXECUTED 10c8b9: 53 push %ebx <== NOT EXECUTED 10c8ba: 6a 00 push $0x0 <== NOT EXECUTED 10c8bc: e8 9f ff ff ff call 10c860 <== NOT EXECUTED /* * sigtimedwait() returns the signal number while sigsuspend() * is supposed to return -1 and EINTR when a signal is caught. */ if ( status != -1 ) 10c8c1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c8c4: 46 inc %esi <== NOT EXECUTED 10c8c5: 75 0d jne 10c8d4 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINTR ); return status; } 10c8c7: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10c8cc: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c8cf: 5b pop %ebx <== NOT EXECUTED 10c8d0: 5e pop %esi <== NOT EXECUTED 10c8d1: c9 leave <== NOT EXECUTED 10c8d2: c3 ret <== NOT EXECUTED 10c8d3: 90 nop <== NOT EXECUTED /* * sigtimedwait() returns the signal number while sigsuspend() * is supposed to return -1 and EINTR when a signal is caught. */ if ( status != -1 ) rtems_set_errno_and_return_minus_one( EINTR ); 10c8d4: e8 e3 76 00 00 call 113fbc <__errno> <== NOT EXECUTED 10c8d9: c7 00 04 00 00 00 movl $0x4,(%eax) <== NOT EXECUTED 10c8df: eb e6 jmp 10c8c7 <== NOT EXECUTED 0010adc8 : int sigtimedwait( const sigset_t *set, siginfo_t *info, const struct timespec *timeout ) { 10adc8: 55 push %ebp <== NOT EXECUTED 10adc9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10adcb: 57 push %edi <== NOT EXECUTED 10adcc: 56 push %esi <== NOT EXECUTED 10adcd: 53 push %ebx <== NOT EXECUTED 10adce: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10add1: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10add4: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED * NOTE: This is very specifically a RELATIVE not ABSOLUTE time * in the Open Group specification. */ interval = 0; if ( timeout ) { 10add7: 85 db test %ebx,%ebx <== NOT EXECUTED 10add9: 0f 84 1d 01 00 00 je 10aefc <== NOT EXECUTED if ( !_Timespec_Is_valid( timeout ) ) 10addf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ade2: 53 push %ebx <== NOT EXECUTED 10ade3: e8 60 36 00 00 call 10e448 <_Timespec_Is_valid> <== NOT EXECUTED 10ade8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10adeb: 84 c0 test %al,%al <== NOT EXECUTED 10aded: 0f 84 55 01 00 00 je 10af48 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); 10adf3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10adf6: 53 push %ebx <== NOT EXECUTED 10adf7: e8 b0 36 00 00 call 10e4ac <_Timespec_To_ticks> <== NOT EXECUTED 10adfc: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !interval ) 10adfe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae01: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae03: 0f 84 3f 01 00 00 je 10af48 <== NOT EXECUTED /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10ae09: 85 f6 test %esi,%esi <== NOT EXECUTED 10ae0b: 0f 84 f5 00 00 00 je 10af06 <== NOT EXECUTED the_thread = _Thread_Executing; 10ae11: 8b 0d 7c 2b 12 00 mov 0x122b7c,%ecx <== NOT EXECUTED api = the_thread->API_Extensions[ THREAD_API_POSIX ]; 10ae17: 8b b9 f8 00 00 00 mov 0xf8(%ecx),%edi <== NOT EXECUTED * What if they are already pending? */ /* API signals pending? */ _ISR_Disable( level ); 10ae1d: 9c pushf <== NOT EXECUTED 10ae1e: fa cli <== NOT EXECUTED 10ae1f: 8f 45 e0 popl -0x20(%ebp) <== NOT EXECUTED if ( *set & api->signals_pending ) { 10ae22: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ae25: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10ae27: 8b 87 c8 00 00 00 mov 0xc8(%edi),%eax <== NOT EXECUTED 10ae2d: 85 c2 test %eax,%edx <== NOT EXECUTED 10ae2f: 0f 85 db 00 00 00 jne 10af10 <== NOT EXECUTED return the_info->si_signo; } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { 10ae35: a1 e0 32 12 00 mov 0x1232e0,%eax <== NOT EXECUTED 10ae3a: 85 c2 test %eax,%edx <== NOT EXECUTED 10ae3c: 0f 85 82 00 00 00 jne 10aec4 <== NOT EXECUTED the_info->si_code = SI_USER; the_info->si_value.sival_int = 0; return signo; } the_info->si_signo = -1; 10ae42: c7 06 ff ff ff ff movl $0xffffffff,(%esi) <== NOT EXECUTED 10ae48: a1 b8 2a 12 00 mov 0x122ab8,%eax <== NOT EXECUTED 10ae4d: 40 inc %eax <== NOT EXECUTED 10ae4e: a3 b8 2a 12 00 mov %eax,0x122ab8 <== NOT EXECUTED _Thread_Disable_dispatch(); the_thread->Wait.queue = &_POSIX_signals_Wait_queue; 10ae53: c7 41 44 a0 32 12 00 movl $0x1232a0,0x44(%ecx) <== NOT EXECUTED the_thread->Wait.return_code = EINTR; 10ae5a: c7 41 34 04 00 00 00 movl $0x4,0x34(%ecx) <== NOT EXECUTED the_thread->Wait.option = *set; 10ae61: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10ae64: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10ae66: 89 41 30 mov %eax,0x30(%ecx) <== NOT EXECUTED the_thread->Wait.return_argument = the_info; 10ae69: 89 71 28 mov %esi,0x28(%ecx) <== NOT EXECUTED 10ae6c: c7 05 d0 32 12 00 01 movl $0x1,0x1232d0 <== NOT EXECUTED 10ae73: 00 00 00 <== NOT EXECUTED _Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue ); _ISR_Enable( level ); 10ae76: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10ae79: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval ); 10ae7a: 50 push %eax <== NOT EXECUTED 10ae7b: 68 f0 df 10 00 push $0x10dff0 <== NOT EXECUTED 10ae80: 53 push %ebx <== NOT EXECUTED 10ae81: 68 a0 32 12 00 push $0x1232a0 <== NOT EXECUTED 10ae86: e8 15 2e 00 00 call 10dca0 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 10ae8b: e8 50 29 00 00 call 10d7e0 <_Thread_Enable_dispatch> <== NOT EXECUTED /* * 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 ); 10ae90: c7 04 24 00 00 00 00 movl $0x0,(%esp) <== NOT EXECUTED 10ae97: 6a 00 push $0x0 <== NOT EXECUTED 10ae99: 56 push %esi <== NOT EXECUTED 10ae9a: ff 36 pushl (%esi) <== NOT EXECUTED 10ae9c: 57 push %edi <== NOT EXECUTED 10ae9d: e8 d2 58 00 00 call 110774 <_POSIX_signals_Clear_signals> <== NOT EXECUTED errno = _Thread_Executing->Wait.return_code; 10aea2: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10aea5: e8 a6 74 00 00 call 112350 <__errno> <== NOT EXECUTED 10aeaa: 8b 15 7c 2b 12 00 mov 0x122b7c,%edx <== NOT EXECUTED 10aeb0: 8b 52 34 mov 0x34(%edx),%edx <== NOT EXECUTED 10aeb3: 89 10 mov %edx,(%eax) <== NOT EXECUTED return the_info->si_signo; 10aeb5: 8b 1e mov (%esi),%ebx <== NOT EXECUTED } 10aeb7: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10aeb9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aebc: 5b pop %ebx <== NOT EXECUTED 10aebd: 5e pop %esi <== NOT EXECUTED 10aebe: 5f pop %edi <== NOT EXECUTED 10aebf: c9 leave <== NOT EXECUTED 10aec0: c3 ret <== NOT EXECUTED 10aec1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } /* Process pending signals? */ if ( *set & _POSIX_signals_Pending ) { signo = _POSIX_signals_Get_highest( _POSIX_signals_Pending ); 10aec4: 50 push %eax <== NOT EXECUTED 10aec5: e8 b2 fe ff ff call 10ad7c <_POSIX_signals_Get_highest> <== NOT EXECUTED 10aeca: 89 c3 mov %eax,%ebx <== NOT EXECUTED _POSIX_signals_Clear_signals( api, signo, the_info, true, false ); 10aecc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10aecf: 6a 00 push $0x0 <== NOT EXECUTED 10aed1: 6a 01 push $0x1 <== NOT EXECUTED 10aed3: 56 push %esi <== NOT EXECUTED 10aed4: 50 push %eax <== NOT EXECUTED 10aed5: 57 push %edi <== NOT EXECUTED 10aed6: e8 99 58 00 00 call 110774 <_POSIX_signals_Clear_signals> <== NOT EXECUTED _ISR_Enable( level ); 10aedb: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10aede: 9d popf <== NOT EXECUTED the_info->si_signo = signo; 10aedf: 89 1e mov %ebx,(%esi) <== NOT EXECUTED the_info->si_code = SI_USER; 10aee1: c7 46 04 01 00 00 00 movl $0x1,0x4(%esi) <== NOT EXECUTED the_info->si_value.sival_int = 0; 10aee8: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) <== NOT EXECUTED 10aeef: 83 c4 20 add $0x20,%esp <== NOT EXECUTED */ _POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false ); errno = _Thread_Executing->Wait.return_code; return the_info->si_signo; } 10aef2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10aef4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aef7: 5b pop %ebx <== NOT EXECUTED 10aef8: 5e pop %esi <== NOT EXECUTED 10aef9: 5f pop %edi <== NOT EXECUTED 10aefa: c9 leave <== NOT EXECUTED 10aefb: c3 ret <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 10aefc: 31 db xor %ebx,%ebx <== NOT EXECUTED /* * Initialize local variables. */ the_info = ( info ) ? info : &signal_information; 10aefe: 85 f6 test %esi,%esi <== NOT EXECUTED 10af00: 0f 85 0b ff ff ff jne 10ae11 <== NOT EXECUTED 10af06: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 10af09: e9 03 ff ff ff jmp 10ae11 <== NOT EXECUTED 10af0e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* 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 ); 10af10: 50 push %eax <== NOT EXECUTED 10af11: e8 66 fe ff ff call 10ad7c <_POSIX_signals_Get_highest> <== NOT EXECUTED 10af16: 89 06 mov %eax,(%esi) <== NOT EXECUTED _POSIX_signals_Clear_signals( 10af18: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10af1b: 6a 00 push $0x0 <== NOT EXECUTED 10af1d: 6a 00 push $0x0 <== NOT EXECUTED 10af1f: 56 push %esi <== NOT EXECUTED 10af20: 50 push %eax <== NOT EXECUTED 10af21: 57 push %edi <== NOT EXECUTED 10af22: e8 4d 58 00 00 call 110774 <_POSIX_signals_Clear_signals> <== NOT EXECUTED the_info->si_signo, the_info, false, false ); _ISR_Enable( level ); 10af27: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10af2a: 9d popf <== NOT EXECUTED the_info->si_code = SI_USER; 10af2b: c7 46 04 01 00 00 00 movl $0x1,0x4(%esi) <== NOT EXECUTED the_info->si_value.sival_int = 0; 10af32: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) <== NOT EXECUTED return the_info->si_signo; 10af39: 8b 1e mov (%esi),%ebx <== NOT EXECUTED 10af3b: 83 c4 20 add $0x20,%esp <== NOT EXECUTED */ _POSIX_signals_Clear_signals( api, the_info->si_signo, the_info, false, false ); errno = _Thread_Executing->Wait.return_code; return the_info->si_signo; } 10af3e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10af40: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10af43: 5b pop %ebx <== NOT EXECUTED 10af44: 5e pop %esi <== NOT EXECUTED 10af45: 5f pop %edi <== NOT EXECUTED 10af46: c9 leave <== NOT EXECUTED 10af47: c3 ret <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); interval = _Timespec_To_ticks( timeout ); if ( !interval ) rtems_set_errno_and_return_minus_one( EINVAL ); 10af48: e8 03 74 00 00 call 112350 <__errno> <== NOT EXECUTED 10af4d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10af53: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10af58: e9 5a ff ff ff jmp 10aeb7 <== NOT EXECUTED 0010cae0 : int sigwait( const sigset_t *set, int *sig ) { 10cae0: 55 push %ebp <== NOT EXECUTED 10cae1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cae3: 53 push %ebx <== NOT EXECUTED 10cae4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cae7: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED int status; status = sigtimedwait( set, NULL, NULL ); 10caea: 6a 00 push $0x0 <== NOT EXECUTED 10caec: 6a 00 push $0x0 <== NOT EXECUTED 10caee: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10caf1: e8 3a fe ff ff call 10c930 <== NOT EXECUTED if ( status != -1 ) { 10caf6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10caf9: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10cafc: 74 0e je 10cb0c <== NOT EXECUTED if ( sig ) 10cafe: 85 db test %ebx,%ebx <== NOT EXECUTED 10cb00: 74 02 je 10cb04 <== NOT EXECUTED *sig = status; 10cb02: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10cb04: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } return errno; } 10cb06: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cb09: c9 leave <== NOT EXECUTED 10cb0a: c3 ret <== NOT EXECUTED 10cb0b: 90 nop <== NOT EXECUTED if ( sig ) *sig = status; return 0; } return errno; 10cb0c: e8 ab 74 00 00 call 113fbc <__errno> <== NOT EXECUTED 10cb11: 8b 00 mov (%eax),%eax <== NOT EXECUTED } 10cb13: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cb16: c9 leave <== NOT EXECUTED 10cb17: c3 ret <== NOT EXECUTED 0010cac8 : int sigwaitinfo( const sigset_t *set, siginfo_t *info ) { 10cac8: 55 push %ebp <== NOT EXECUTED 10cac9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cacb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return sigtimedwait( set, info, NULL ); 10cace: 6a 00 push $0x0 <== NOT EXECUTED 10cad0: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10cad3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cad6: e8 55 fe ff ff call 10c930 <== NOT EXECUTED } 10cadb: c9 leave <== NOT EXECUTED 10cadc: c3 ret <== NOT EXECUTED 00108aec : /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) { 108aec: 55 push %ebp <== NOT EXECUTED 108aed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108aef: 56 push %esi <== NOT EXECUTED 108af0: 53 push %ebx <== NOT EXECUTED 108af1: 89 d6 mov %edx,%esi <== NOT EXECUTED 108af3: 88 c3 mov %al,%bl <== NOT EXECUTED int i; /* * Obtain output semaphore if character will be echoed */ if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) { 108af5: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx) <== NOT EXECUTED 108afc: 75 0e jne 108b0c <== 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); 108afe: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED } return i; } 108b01: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108b04: 5b pop %ebx <== NOT EXECUTED 108b05: 5e pop %esi <== NOT EXECUTED 108b06: c9 leave <== 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); 108b07: e9 a8 fe ff ff jmp 1089b4 <== 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); 108b0c: 50 push %eax <== NOT EXECUTED 108b0d: 6a 00 push $0x0 <== NOT EXECUTED 108b0f: 6a 00 push $0x0 <== NOT EXECUTED 108b11: ff 72 18 pushl 0x18(%edx) <== NOT EXECUTED 108b14: e8 93 18 00 00 call 10a3ac <== NOT EXECUTED i = iproc (c, tty); 108b19: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 108b1c: 89 f2 mov %esi,%edx <== NOT EXECUTED 108b1e: e8 91 fe ff ff call 1089b4 <== NOT EXECUTED 108b23: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_semaphore_release (tty->osem); 108b25: 59 pop %ecx <== NOT EXECUTED 108b26: ff 76 18 pushl 0x18(%esi) <== NOT EXECUTED 108b29: e8 76 19 00 00 call 10a4a4 <== NOT EXECUTED 108b2e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { i = iproc (c, tty); } return i; } 108b31: 89 d8 mov %ebx,%eax <== NOT EXECUTED 108b33: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108b36: 5b pop %ebx <== NOT EXECUTED 108b37: 5e pop %esi <== NOT EXECUTED 108b38: c9 leave <== NOT EXECUTED 108b39: c3 ret <== NOT EXECUTED 00109c9c : unsigned int sleep( unsigned int seconds ) { 109c9c: 55 push %ebp <== NOT EXECUTED 109c9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109c9f: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED struct timespec tp; struct timespec tm; tp.tv_sec = seconds; 109ca2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 109ca5: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED tp.tv_nsec = 0; 109ca8: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED nanosleep( &tp, &tm ); 109caf: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 109cb2: 50 push %eax <== NOT EXECUTED 109cb3: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 109cb6: 50 push %eax <== NOT EXECUTED 109cb7: e8 18 55 00 00 call 10f1d4 <== NOT EXECUTED 109cbc: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED return tm.tv_sec; /* seconds remaining */ } 109cbf: c9 leave <== NOT EXECUTED 109cc0: c3 ret <== NOT EXECUTED 0010c950 : int _STAT_NAME( const char *path, struct stat *buf ) { 10c950: 55 push %ebp <== NOT EXECUTED 10c951: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c953: 57 push %edi <== NOT EXECUTED 10c954: 56 push %esi <== NOT EXECUTED 10c955: 53 push %ebx <== NOT EXECUTED 10c956: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10c959: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !buf ) 10c95c: 85 db test %ebx,%ebx <== NOT EXECUTED 10c95e: 0f 84 8c 00 00 00 je 10c9f0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); status = rtems_filesystem_evaluate_path( path, 0, &loc, _STAT_FOLLOW_LINKS ); 10c964: 6a 01 push $0x1 <== NOT EXECUTED 10c966: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 10c969: 56 push %esi <== NOT EXECUTED 10c96a: 6a 00 push $0x0 <== NOT EXECUTED 10c96c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c96f: e8 b8 e8 ff ff call 10b22c <== NOT EXECUTED if ( status != 0 ) 10c974: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c977: 85 c0 test %eax,%eax <== NOT EXECUTED 10c979: 75 65 jne 10c9e0 <== NOT EXECUTED return -1; if ( !loc.handlers->fstat_h ){ 10c97b: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10c97e: 8b 42 18 mov 0x18(%edx),%eax <== NOT EXECUTED 10c981: 85 c0 test %eax,%eax <== NOT EXECUTED 10c983: 74 39 je 10c9be <== NOT EXECUTED /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( buf, 0, sizeof(struct stat) ); 10c985: b9 4c 00 00 00 mov $0x4c,%ecx <== NOT EXECUTED 10c98a: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c98c: 89 df mov %ebx,%edi <== NOT EXECUTED 10c98e: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED status = (*loc.handlers->fstat_h)( &loc, buf ); 10c990: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c993: 53 push %ebx <== NOT EXECUTED 10c994: 56 push %esi <== NOT EXECUTED 10c995: ff 52 18 call *0x18(%edx) <== NOT EXECUTED 10c998: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 10c99a: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10c99d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c9a0: 85 c0 test %eax,%eax <== NOT EXECUTED 10c9a2: 74 10 je 10c9b4 <== NOT EXECUTED 10c9a4: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10c9a7: 85 c0 test %eax,%eax <== NOT EXECUTED 10c9a9: 74 09 je 10c9b4 <== NOT EXECUTED 10c9ab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c9ae: 56 push %esi <== NOT EXECUTED 10c9af: ff d0 call *%eax <== NOT EXECUTED 10c9b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return status; } 10c9b4: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c9b6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c9b9: 5b pop %ebx <== NOT EXECUTED 10c9ba: 5e pop %esi <== NOT EXECUTED 10c9bb: 5f pop %edi <== NOT EXECUTED 10c9bc: c9 leave <== NOT EXECUTED 10c9bd: c3 ret <== NOT EXECUTED 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 ); 10c9be: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10c9c1: 85 c0 test %eax,%eax <== NOT EXECUTED 10c9c3: 74 10 je 10c9d5 <== NOT EXECUTED 10c9c5: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10c9c8: 85 c0 test %eax,%eax <== NOT EXECUTED 10c9ca: 74 09 je 10c9d5 <== NOT EXECUTED 10c9cc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c9cf: 56 push %esi <== NOT EXECUTED 10c9d0: ff d0 call *%eax <== NOT EXECUTED 10c9d2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 10c9d5: e8 7a 4e 02 00 call 131854 <__errno> <== NOT EXECUTED 10c9da: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10c9e0: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED status = (*loc.handlers->fstat_h)( &loc, buf ); rtems_filesystem_freenode( &loc ); return status; } 10c9e5: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c9e7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c9ea: 5b pop %ebx <== NOT EXECUTED 10c9eb: 5e pop %esi <== NOT EXECUTED 10c9ec: 5f pop %edi <== NOT EXECUTED 10c9ed: c9 leave <== NOT EXECUTED 10c9ee: c3 ret <== NOT EXECUTED 10c9ef: 90 nop <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !buf ) rtems_set_errno_and_return_minus_one( EFAULT ); 10c9f0: e8 5f 4e 02 00 call 131854 <__errno> <== NOT EXECUTED 10c9f5: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 10c9fb: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED status = (*loc.handlers->fstat_h)( &loc, buf ); rtems_filesystem_freenode( &loc ); return status; } 10ca00: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10ca02: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ca05: 5b pop %ebx <== NOT EXECUTED 10ca06: 5e pop %esi <== NOT EXECUTED 10ca07: 5f pop %edi <== NOT EXECUTED 10ca08: c9 leave <== NOT EXECUTED 10ca09: c3 ret <== NOT EXECUTED 00125380 : int symlink( const char *actualpath, const char *sympath ) { 125380: 55 push %ebp <== NOT EXECUTED 125381: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125383: 57 push %edi <== NOT EXECUTED 125384: 56 push %esi <== NOT EXECUTED 125385: 53 push %ebx <== NOT EXECUTED 125386: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 125389: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED rtems_filesystem_location_info_t loc; int i; const char *name_start; int result; rtems_filesystem_get_start_loc( sympath, &i, &loc ); 12538c: 8a 03 mov (%ebx),%al <== NOT EXECUTED 12538e: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 125390: 74 26 je 1253b8 <== NOT EXECUTED 125392: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 125394: 74 22 je 1253b8 <== NOT EXECUTED 125396: 84 c0 test %al,%al <== NOT EXECUTED 125398: 74 1e je 1253b8 <== NOT EXECUTED 12539a: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 12539d: 89 45 c8 mov %eax,-0x38(%ebp) <== NOT EXECUTED 1253a0: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED 1253a5: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 1253a8: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1253ad: 8b 7d c8 mov -0x38(%ebp),%edi <== NOT EXECUTED 1253b0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1253b2: 31 d2 xor %edx,%edx <== NOT EXECUTED 1253b4: eb 1f jmp 1253d5 <== NOT EXECUTED 1253b6: 66 90 xchg %ax,%ax <== NOT EXECUTED 1253b8: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 1253bb: 89 45 c8 mov %eax,-0x38(%ebp) <== NOT EXECUTED 1253be: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED 1253c3: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 1253c6: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1253cb: 8b 7d c8 mov -0x38(%ebp),%edi <== NOT EXECUTED 1253ce: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1253d0: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start ); 1253d5: 51 push %ecx <== NOT EXECUTED 1253d6: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 1253d9: 50 push %eax <== NOT EXECUTED 1253da: ff 75 c8 pushl -0x38(%ebp) <== NOT EXECUTED 1253dd: 8d 04 13 lea (%ebx,%edx,1),%eax <== NOT EXECUTED 1253e0: 50 push %eax <== NOT EXECUTED 1253e1: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1253e4: ff 50 04 call *0x4(%eax) <== NOT EXECUTED if ( result != 0 ) 1253e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1253ea: 85 c0 test %eax,%eax <== NOT EXECUTED 1253ec: 75 5e jne 12544c <== NOT EXECUTED return -1; if ( !loc.ops->symlink_h ) { 1253ee: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1253f1: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 1253f4: 85 d2 test %edx,%edx <== NOT EXECUTED 1253f6: 74 34 je 12542c <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->symlink_h)( &loc, actualpath, name_start); 1253f8: 50 push %eax <== NOT EXECUTED 1253f9: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 1253fc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1253ff: ff 75 c8 pushl -0x38(%ebp) <== NOT EXECUTED 125402: ff d2 call *%edx <== NOT EXECUTED 125404: 89 c6 mov %eax,%esi <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 125406: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 125409: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12540c: 85 c0 test %eax,%eax <== NOT EXECUTED 12540e: 74 12 je 125422 <== NOT EXECUTED 125410: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 125413: 85 c0 test %eax,%eax <== NOT EXECUTED 125415: 74 0b je 125422 <== NOT EXECUTED 125417: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12541a: ff 75 c8 pushl -0x38(%ebp) <== NOT EXECUTED 12541d: ff d0 call *%eax <== NOT EXECUTED 12541f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 125422: 89 f0 mov %esi,%eax <== NOT EXECUTED 125424: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 125427: 5b pop %ebx <== NOT EXECUTED 125428: 5e pop %esi <== NOT EXECUTED 125429: 5f pop %edi <== NOT EXECUTED 12542a: c9 leave <== NOT EXECUTED 12542b: c3 ret <== NOT EXECUTED result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start ); if ( result != 0 ) return -1; if ( !loc.ops->symlink_h ) { rtems_filesystem_freenode( &loc ); 12542c: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12542f: 85 c0 test %eax,%eax <== NOT EXECUTED 125431: 74 0b je 12543e <== NOT EXECUTED 125433: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125436: ff 75 c8 pushl -0x38(%ebp) <== NOT EXECUTED 125439: ff d0 call *%eax <== NOT EXECUTED 12543b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 12543e: e8 11 c4 00 00 call 131854 <__errno> <== NOT EXECUTED 125443: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 125449: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 12544c: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED result = (*loc.ops->symlink_h)( &loc, actualpath, name_start); rtems_filesystem_freenode( &loc ); return result; } 125451: 89 f0 mov %esi,%eax <== NOT EXECUTED 125453: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 125456: 5b pop %ebx <== NOT EXECUTED 125457: 5e pop %esi <== NOT EXECUTED 125458: 5f pop %edi <== NOT EXECUTED 125459: c9 leave <== NOT EXECUTED 12545a: c3 ret <== NOT EXECUTED 001095c8 : * We have to extern it here. */ extern struct _reent libc_global_reent; void sync(void) { 1095c8: 55 push %ebp <== NOT EXECUTED 1095c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1095cb: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED /* * Walk the one used initially by RTEMS. */ _fwalk(&libc_global_reent, sync_wrapper); 1095ce: 68 f0 95 10 00 push $0x1095f0 <== NOT EXECUTED 1095d3: 68 80 15 12 00 push $0x121580 <== NOT EXECUTED 1095d8: e8 c3 a7 00 00 call 113da0 <_fwalk> <== NOT EXECUTED */ /* * Now walk all the per-thread reentrancy structures. */ rtems_iterate_over_all_threads(sync_per_thread); 1095dd: c7 04 24 7c 95 10 00 movl $0x10957c,(%esp) <== NOT EXECUTED 1095e4: e8 8b 38 00 00 call 10ce74 <== NOT EXECUTED 1095e9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1095ec: c9 leave <== NOT EXECUTED 1095ed: c3 ret <== NOT EXECUTED 0010957c : fdatasync(fn); } /* iterate over all FILE *'s for this thread */ static void sync_per_thread(Thread_Control *t) { 10957c: 55 push %ebp <== NOT EXECUTED 10957d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10957f: 53 push %ebx <== NOT EXECUTED 109580: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 109583: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED /* * The sync_wrapper() function will operate on the current thread's * reent structure so we will temporarily use that. */ this_reent = t->libc_reent; 109586: 8b 91 f0 00 00 00 mov 0xf0(%ecx),%edx <== NOT EXECUTED if ( this_reent ) { 10958c: 85 d2 test %edx,%edx <== NOT EXECUTED 10958e: 74 32 je 1095c2 <== NOT EXECUTED current_reent = _Thread_Executing->libc_reent; 109590: a1 7c 3c 12 00 mov 0x123c7c,%eax <== NOT EXECUTED 109595: 8b 98 f0 00 00 00 mov 0xf0(%eax),%ebx <== NOT EXECUTED _Thread_Executing->libc_reent = this_reent; 10959b: 89 90 f0 00 00 00 mov %edx,0xf0(%eax) <== NOT EXECUTED _fwalk (t->libc_reent, sync_wrapper); 1095a1: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1095a4: 68 f0 95 10 00 push $0x1095f0 <== NOT EXECUTED 1095a9: ff b1 f0 00 00 00 pushl 0xf0(%ecx) <== NOT EXECUTED 1095af: e8 ec a7 00 00 call 113da0 <_fwalk> <== NOT EXECUTED _Thread_Executing->libc_reent = current_reent; 1095b4: a1 7c 3c 12 00 mov 0x123c7c,%eax <== NOT EXECUTED 1095b9: 89 98 f0 00 00 00 mov %ebx,0xf0(%eax) <== NOT EXECUTED 1095bf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 1095c2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1095c5: c9 leave <== NOT EXECUTED 1095c6: c3 ret <== NOT EXECUTED 001095f0 : /* XXX check standards -- Linux version appears to be void */ void _fwalk(struct _reent *, void *); static void sync_wrapper(FILE *f) { 1095f0: 55 push %ebp <== NOT EXECUTED 1095f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1095f3: 53 push %ebx <== NOT EXECUTED 1095f4: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED int fn = fileno(f); 1095f7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1095fa: e8 25 9e 00 00 call 113424 <== NOT EXECUTED 1095ff: 89 c3 mov %eax,%ebx <== NOT EXECUTED fsync(fn); 109601: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 109604: e8 2f ed ff ff call 108338 <== NOT EXECUTED fdatasync(fn); 109609: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10960c: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 10960f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 109612: c9 leave <== NOT EXECUTED static void sync_wrapper(FILE *f) { int fn = fileno(f); fsync(fn); fdatasync(fn); 109613: e9 b0 ea ff ff jmp 1080c8 <== NOT EXECUTED 00109ca0 : */ long sysconf( int name ) { 109ca0: 55 push %ebp <== NOT EXECUTED 109ca1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109ca3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED switch (name) { 109ca6: 83 7d 08 04 cmpl $0x4,0x8(%ebp) <== NOT EXECUTED 109caa: 74 38 je 109ce4 <== NOT EXECUTED 109cac: 7e 16 jle 109cc4 <== NOT EXECUTED 109cae: 83 7d 08 08 cmpl $0x8,0x8(%ebp) <== NOT EXECUTED 109cb2: 74 28 je 109cdc <== NOT EXECUTED 109cb4: 83 7d 08 33 cmpl $0x33,0x8(%ebp) <== NOT EXECUTED 109cb8: 75 10 jne 109cca <== NOT EXECUTED 109cba: b8 00 04 00 00 mov $0x400,%eax <== NOT EXECUTED default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 109cbf: c9 leave <== NOT EXECUTED 109cc0: c3 ret <== NOT EXECUTED 109cc1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED long sysconf( int name ) { switch (name) { 109cc4: 83 7d 08 02 cmpl $0x2,0x8(%ebp) <== NOT EXECUTED 109cc8: 74 22 je 109cec <== NOT EXECUTED default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 109cca: e8 e5 74 00 00 call 1111b4 <__errno> <== NOT EXECUTED 109ccf: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 109cd5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 109cda: c9 leave <== NOT EXECUTED 109cdb: c3 ret <== NOT EXECUTED long sysconf( int name ) { switch (name) { 109cdc: b8 00 10 00 00 mov $0x1000,%eax <== NOT EXECUTED default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 109ce1: c9 leave <== NOT EXECUTED 109ce2: c3 ret <== NOT EXECUTED 109ce3: 90 nop <== NOT EXECUTED switch (name) { case _SC_CLK_TCK: return (TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick); case _SC_OPEN_MAX: { return rtems_libio_number_iops; 109ce4: a1 a0 d5 11 00 mov 0x11d5a0,%eax <== NOT EXECUTED default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 109ce9: c9 leave <== NOT EXECUTED 109cea: c3 ret <== NOT EXECUTED 109ceb: 90 nop <== NOT EXECUTED ) { switch (name) { case _SC_CLK_TCK: return (TOD_MICROSECONDS_PER_SECOND / _TOD_Microseconds_per_tick); 109cec: b8 40 42 0f 00 mov $0xf4240,%eax <== NOT EXECUTED 109cf1: 31 d2 xor %edx,%edx <== NOT EXECUTED 109cf3: f7 35 20 1e 12 00 divl 0x121e20 <== NOT EXECUTED default: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 109cf9: c9 leave <== NOT EXECUTED 109cfa: c3 ret <== NOT EXECUTED 0012545c : #include int tcdrain( int fd ) { 12545c: 55 push %ebp <== NOT EXECUTED 12545d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12545f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return ioctl( fd, RTEMS_IO_TCDRAIN, 0 ); 125462: 6a 00 push $0x0 <== NOT EXECUTED 125464: 6a 03 push $0x3 <== NOT EXECUTED 125466: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125469: e8 d6 f3 ff ff call 124844 <== NOT EXECUTED } 12546e: c9 leave <== NOT EXECUTED 12546f: c3 ret <== NOT EXECUTED 00115778 : int tcgetattr( int fd, struct termios *tp ) { 115778: 55 push %ebp <== NOT EXECUTED 115779: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11577b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return ioctl( fd, RTEMS_IO_GET_ATTRIBUTES, tp ); 11577e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 115781: 6a 01 push $0x1 <== NOT EXECUTED 115783: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 115786: e8 55 35 00 00 call 118ce0 <== NOT EXECUTED } 11578b: c9 leave <== NOT EXECUTED 11578c: c3 ret <== NOT EXECUTED 00115790 : int tcsetattr( int fd, int opt, struct termios *tp ) { 115790: 55 push %ebp <== NOT EXECUTED 115791: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115793: 56 push %esi <== NOT EXECUTED 115794: 53 push %ebx <== NOT EXECUTED 115795: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 115798: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11579b: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED switch (opt) { 11579e: 85 c0 test %eax,%eax <== NOT EXECUTED 1157a0: 74 2c je 1157ce <== NOT EXECUTED 1157a2: 48 dec %eax <== NOT EXECUTED 1157a3: 74 17 je 1157bc <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 1157a5: e8 d2 3e 00 00 call 11967c <__errno> <== NOT EXECUTED 1157aa: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); } } 1157b0: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1157b5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1157b8: 5b pop %ebx <== NOT EXECUTED 1157b9: 5e pop %esi <== NOT EXECUTED 1157ba: c9 leave <== NOT EXECUTED 1157bb: c3 ret <== NOT EXECUTED switch (opt) { default: rtems_set_errno_and_return_minus_one( ENOTSUP ); case TCSADRAIN: if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0) 1157bc: 50 push %eax <== NOT EXECUTED 1157bd: 6a 00 push $0x0 <== NOT EXECUTED 1157bf: 6a 03 push $0x3 <== NOT EXECUTED 1157c1: 56 push %esi <== NOT EXECUTED 1157c2: e8 19 35 00 00 call 118ce0 <== NOT EXECUTED 1157c7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1157ca: 85 c0 test %eax,%eax <== NOT EXECUTED 1157cc: 78 e2 js 1157b0 <== NOT EXECUTED return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 1157ce: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 1157d1: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp) <== NOT EXECUTED 1157d8: 89 75 08 mov %esi,0x8(%ebp) <== NOT EXECUTED } } 1157db: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1157de: 5b pop %ebx <== NOT EXECUTED 1157df: 5e pop %esi <== NOT EXECUTED 1157e0: c9 leave <== NOT EXECUTED return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 1157e1: e9 fa 34 00 00 jmp 118ce0 <== NOT EXECUTED 0010a274 : #include long telldir( DIR *dirp ) { 10a274: 55 push %ebp <== NOT EXECUTED 10a275: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a277: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a27a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED rtems_libio_t *iop; if ( !dirp ) 10a27d: 85 c0 test %eax,%eax <== NOT EXECUTED 10a27f: 74 39 je 10a2ba <== NOT EXECUTED /* * Get the file control block structure associated with the * file descriptor */ iop = rtems_libio_iop( dirp->dd_fd ); 10a281: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10a283: 3b 15 c0 05 12 00 cmp 0x1205c0,%edx <== NOT EXECUTED 10a289: 73 19 jae 10a2a4 <== NOT EXECUTED 10a28b: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10a28e: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 10a291: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED if (iop == NULL) 10a294: 03 05 68 4b 12 00 add 0x124b68,%eax <== NOT EXECUTED 10a29a: 74 08 je 10a2a4 <== NOT EXECUTED assert(0); return (long)( iop->offset ); 10a29c: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED } 10a29f: c9 leave <== NOT EXECUTED 10a2a0: c3 ret <== NOT EXECUTED 10a2a1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ iop = rtems_libio_iop( dirp->dd_fd ); if (iop == NULL) assert(0); 10a2a4: 68 1e c7 11 00 push $0x11c71e <== NOT EXECUTED 10a2a9: 68 22 e2 11 00 push $0x11e222 <== NOT EXECUTED 10a2ae: 6a 2c push $0x2c <== NOT EXECUTED 10a2b0: 68 d8 e1 11 00 push $0x11e1d8 <== NOT EXECUTED 10a2b5: e8 f2 df ff ff call 1082ac <__assert_func> <== NOT EXECUTED ) { rtems_libio_t *iop; if ( !dirp ) rtems_set_errno_and_return_minus_one( EBADF ); 10a2ba: e8 51 9c 00 00 call 113f10 <__errno> <== NOT EXECUTED 10a2bf: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10a2c5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED if (iop == NULL) assert(0); return (long)( iop->offset ); } 10a2ca: c9 leave <== NOT EXECUTED 10a2cb: c3 ret <== NOT EXECUTED 00107e0c : #include int termios_baud_to_number( int termios_baud ) { 107e0c: 55 push %ebp <== NOT EXECUTED 107e0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107e0f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED int baud; switch (termios_baud) { 107e12: 83 f8 09 cmp $0x9,%eax <== NOT EXECUTED 107e15: 0f 84 f1 00 00 00 je 107f0c <== NOT EXECUTED 107e1b: 7e 37 jle 107e54 <== NOT EXECUTED 107e1d: 83 f8 0e cmp $0xe,%eax <== NOT EXECUTED 107e20: 0f 84 f6 00 00 00 je 107f1c <== NOT EXECUTED 107e26: 7e 5c jle 107e84 <== NOT EXECUTED 107e28: 3d 02 10 00 00 cmp $0x1002,%eax <== NOT EXECUTED 107e2d: 0f 84 01 01 00 00 je 107f34 <== NOT EXECUTED 107e33: 0f 8e 97 00 00 00 jle 107ed0 <== NOT EXECUTED 107e39: 3d 03 10 00 00 cmp $0x1003,%eax <== NOT EXECUTED 107e3e: 0f 84 e0 00 00 00 je 107f24 <== NOT EXECUTED 107e44: 3d 04 10 00 00 cmp $0x1004,%eax <== NOT EXECUTED 107e49: 75 51 jne 107e9c <== NOT EXECUTED case B9600: baud = 9600; break; case B19200: baud = 19200; break; case B38400: baud = 38400; break; case B57600: baud = 57600; break; case B115200: baud = 115200; break; case B230400: baud = 230400; break; 107e4b: b8 00 08 07 00 mov $0x70800,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107e50: c9 leave <== NOT EXECUTED 107e51: c3 ret <== NOT EXECUTED 107e52: 66 90 xchg %ax,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107e54: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 107e57: 0f 84 b7 00 00 00 je 107f14 <== NOT EXECUTED 107e5d: 7f 45 jg 107ea4 <== NOT EXECUTED 107e5f: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 107e62: 0f 84 8c 00 00 00 je 107ef4 <== NOT EXECUTED 107e68: 0f 8e de 00 00 00 jle 107f4c <== NOT EXECUTED 107e6e: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 107e71: 0f 84 c5 00 00 00 je 107f3c <== NOT EXECUTED 107e77: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 107e7a: 75 20 jne 107e9c <== NOT EXECUTED case B0: baud = 0; break; case B50: baud = 50; break; case B75: baud = 75; break; 107e7c: b8 6e 00 00 00 mov $0x6e,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107e81: c9 leave <== NOT EXECUTED 107e82: c3 ret <== NOT EXECUTED 107e83: 90 nop <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107e84: 83 f8 0b cmp $0xb,%eax <== NOT EXECUTED 107e87: 0f 84 9f 00 00 00 je 107f2c <== NOT EXECUTED 107e8d: 7c 39 jl 107ec8 <== NOT EXECUTED 107e8f: 83 f8 0c cmp $0xc,%eax <== NOT EXECUTED 107e92: 74 50 je 107ee4 <== NOT EXECUTED 107e94: 83 f8 0d cmp $0xd,%eax <== NOT EXECUTED 107e97: 74 62 je 107efb <== NOT EXECUTED 107e99: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED case B19200: baud = 19200; break; case B38400: baud = 38400; break; case B57600: baud = 57600; break; case B115200: baud = 115200; break; case B230400: baud = 230400; break; case B460800: baud = 460800; break; 107e9c: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED default: baud = -1; break; } return baud; } 107ea1: c9 leave <== NOT EXECUTED 107ea2: c3 ret <== NOT EXECUTED 107ea3: 90 nop <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107ea4: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 107ea7: 74 43 je 107eec <== NOT EXECUTED 107ea9: 7c 15 jl 107ec0 <== NOT EXECUTED 107eab: 83 f8 07 cmp $0x7,%eax <== NOT EXECUTED 107eae: 0f 84 90 00 00 00 je 107f44 <== NOT EXECUTED 107eb4: 83 f8 08 cmp $0x8,%eax <== NOT EXECUTED 107eb7: 75 e3 jne 107e9c <== NOT EXECUTED case B75: baud = 75; break; case B110: baud = 110; break; case B134: baud = 135; break; case B150: baud = 150; break; case B200: baud = 200; break; case B300: baud = 300; break; 107eb9: b8 58 02 00 00 mov $0x258,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107ebe: c9 leave <== NOT EXECUTED 107ebf: c3 ret <== NOT EXECUTED switch (termios_baud) { case B0: baud = 0; break; case B50: baud = 50; break; case B75: baud = 75; break; case B110: baud = 110; break; case B134: baud = 135; break; 107ec0: b8 96 00 00 00 mov $0x96,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107ec5: c9 leave <== NOT EXECUTED 107ec6: c3 ret <== NOT EXECUTED 107ec7: 90 nop <== NOT EXECUTED case B134: baud = 135; break; case B150: baud = 150; break; case B200: baud = 200; break; case B300: baud = 300; break; case B600: baud = 600; break; case B1200: baud = 1200; break; 107ec8: b8 08 07 00 00 mov $0x708,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107ecd: c9 leave <== NOT EXECUTED 107ece: c3 ret <== NOT EXECUTED 107ecf: 90 nop <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107ed0: 83 f8 0f cmp $0xf,%eax <== NOT EXECUTED 107ed3: 74 2f je 107f04 <== NOT EXECUTED 107ed5: 3d 01 10 00 00 cmp $0x1001,%eax <== NOT EXECUTED 107eda: 75 c0 jne 107e9c <== NOT EXECUTED case B1800: baud = 1800; break; case B2400: baud = 2400; break; case B4800: baud = 4800; break; case B9600: baud = 9600; break; case B19200: baud = 19200; break; case B38400: baud = 38400; break; 107edc: b8 00 e1 00 00 mov $0xe100,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107ee1: c9 leave <== NOT EXECUTED 107ee2: c3 ret <== NOT EXECUTED 107ee3: 90 nop <== NOT EXECUTED case B200: baud = 200; break; case B300: baud = 300; break; case B600: baud = 600; break; case B1200: baud = 1200; break; case B1800: baud = 1800; break; case B2400: baud = 2400; break; 107ee4: b8 c0 12 00 00 mov $0x12c0,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107ee9: c9 leave <== NOT EXECUTED 107eea: c3 ret <== NOT EXECUTED 107eeb: 90 nop <== NOT EXECUTED case B0: baud = 0; break; case B50: baud = 50; break; case B75: baud = 75; break; case B110: baud = 110; break; case B134: baud = 135; break; case B150: baud = 150; break; 107eec: b8 c8 00 00 00 mov $0xc8,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107ef1: c9 leave <== NOT EXECUTED 107ef2: c3 ret <== NOT EXECUTED 107ef3: 90 nop <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107ef4: b8 32 00 00 00 mov $0x32,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107ef9: c9 leave <== NOT EXECUTED 107efa: c3 ret <== NOT EXECUTED case B300: baud = 300; break; case B600: baud = 600; break; case B1200: baud = 1200; break; case B1800: baud = 1800; break; case B2400: baud = 2400; break; case B4800: baud = 4800; break; 107efb: b8 80 25 00 00 mov $0x2580,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f00: c9 leave <== NOT EXECUTED 107f01: c3 ret <== NOT EXECUTED 107f02: 66 90 xchg %ax,%ax <== NOT EXECUTED case B1200: baud = 1200; break; case B1800: baud = 1800; break; case B2400: baud = 2400; break; case B4800: baud = 4800; break; case B9600: baud = 9600; break; case B19200: baud = 19200; break; 107f04: b8 00 96 00 00 mov $0x9600,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f09: c9 leave <== NOT EXECUTED 107f0a: c3 ret <== NOT EXECUTED 107f0b: 90 nop <== NOT EXECUTED case B110: baud = 110; break; case B134: baud = 135; break; case B150: baud = 150; break; case B200: baud = 200; break; case B300: baud = 300; break; case B600: baud = 600; break; 107f0c: b8 b0 04 00 00 mov $0x4b0,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f11: c9 leave <== NOT EXECUTED 107f12: c3 ret <== NOT EXECUTED 107f13: 90 nop <== NOT EXECUTED switch (termios_baud) { case B0: baud = 0; break; case B50: baud = 50; break; case B75: baud = 75; break; case B110: baud = 110; break; 107f14: b8 87 00 00 00 mov $0x87,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f19: c9 leave <== NOT EXECUTED 107f1a: c3 ret <== NOT EXECUTED 107f1b: 90 nop <== NOT EXECUTED case B600: baud = 600; break; case B1200: baud = 1200; break; case B1800: baud = 1800; break; case B2400: baud = 2400; break; case B4800: baud = 4800; break; case B9600: baud = 9600; break; 107f1c: b8 00 4b 00 00 mov $0x4b00,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f21: c9 leave <== NOT EXECUTED 107f22: c3 ret <== NOT EXECUTED 107f23: 90 nop <== NOT EXECUTED case B4800: baud = 4800; break; case B9600: baud = 9600; break; case B19200: baud = 19200; break; case B38400: baud = 38400; break; case B57600: baud = 57600; break; case B115200: baud = 115200; break; 107f24: b8 00 84 03 00 mov $0x38400,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f29: c9 leave <== NOT EXECUTED 107f2a: c3 ret <== NOT EXECUTED 107f2b: 90 nop <== NOT EXECUTED case B150: baud = 150; break; case B200: baud = 200; break; case B300: baud = 300; break; case B600: baud = 600; break; case B1200: baud = 1200; break; case B1800: baud = 1800; break; 107f2c: b8 60 09 00 00 mov $0x960,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f31: c9 leave <== NOT EXECUTED 107f32: c3 ret <== NOT EXECUTED 107f33: 90 nop <== NOT EXECUTED case B2400: baud = 2400; break; case B4800: baud = 4800; break; case B9600: baud = 9600; break; case B19200: baud = 19200; break; case B38400: baud = 38400; break; case B57600: baud = 57600; break; 107f34: b8 00 c2 01 00 mov $0x1c200,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f39: c9 leave <== NOT EXECUTED 107f3a: c3 ret <== NOT EXECUTED 107f3b: 90 nop <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107f3c: b8 4b 00 00 00 mov $0x4b,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f41: c9 leave <== NOT EXECUTED 107f42: c3 ret <== NOT EXECUTED 107f43: 90 nop <== NOT EXECUTED case B50: baud = 50; break; case B75: baud = 75; break; case B110: baud = 110; break; case B134: baud = 135; break; case B150: baud = 150; break; case B200: baud = 200; break; 107f44: b8 2c 01 00 00 mov $0x12c,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f49: c9 leave <== NOT EXECUTED 107f4a: c3 ret <== NOT EXECUTED 107f4b: 90 nop <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107f4c: 85 c0 test %eax,%eax <== NOT EXECUTED 107f4e: 0f 85 48 ff ff ff jne 107e9c <== NOT EXECUTED 107f54: 31 c0 xor %eax,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f56: c9 leave <== NOT EXECUTED 107f57: c3 ret <== NOT EXECUTED 0010ead8 : int timer_create( clockid_t clock_id, struct sigevent *evp, timer_t *timerid ) { 10ead8: 55 push %ebp <== NOT EXECUTED 10ead9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eadb: 57 push %edi <== NOT EXECUTED 10eadc: 56 push %esi <== NOT EXECUTED 10eadd: 53 push %ebx <== NOT EXECUTED 10eade: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eae1: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10eae4: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED POSIX_Timer_Control *ptimer; if ( clock_id != CLOCK_REALTIME ) 10eae7: 83 7d 08 01 cmpl $0x1,0x8(%ebp) <== NOT EXECUTED 10eaeb: 0f 85 db 00 00 00 jne 10ebcc <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !timerid ) 10eaf1: 85 ff test %edi,%edi <== NOT EXECUTED 10eaf3: 0f 84 d3 00 00 00 je 10ebcc <== NOT EXECUTED /* * The data of the structure evp are checked in order to verify if they * are coherent. */ if (evp != NULL) { 10eaf9: 85 f6 test %esi,%esi <== NOT EXECUTED 10eafb: 74 21 je 10eb1e <== NOT EXECUTED /* The structure has data */ if ( ( evp->sigev_notify != SIGEV_NONE ) && 10eafd: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10eaff: 48 dec %eax <== NOT EXECUTED 10eb00: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10eb03: 0f 87 c3 00 00 00 ja 10ebcc <== NOT EXECUTED ( 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 ) 10eb09: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10eb0c: 85 c0 test %eax,%eax <== NOT EXECUTED 10eb0e: 0f 84 b8 00 00 00 je 10ebcc <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( !is_valid_signo(evp->sigev_signo) ) 10eb14: 48 dec %eax <== NOT EXECUTED 10eb15: 83 f8 1f cmp $0x1f,%eax <== NOT EXECUTED 10eb18: 0f 87 ae 00 00 00 ja 10ebcc <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10eb1e: a1 58 7c 12 00 mov 0x127c58,%eax <== NOT EXECUTED 10eb23: 40 inc %eax <== NOT EXECUTED 10eb24: a3 58 7c 12 00 mov %eax,0x127c58 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 10eb29: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eb2c: 68 e0 7f 12 00 push $0x127fe0 <== NOT EXECUTED 10eb31: e8 c6 1d 00 00 call 1108fc <_Objects_Allocate> <== NOT EXECUTED 10eb36: 89 c3 mov %eax,%ebx <== NOT EXECUTED /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { 10eb38: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eb3b: 85 c0 test %eax,%eax <== NOT EXECUTED 10eb3d: 0f 84 a1 00 00 00 je 10ebe4 <== NOT EXECUTED 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; 10eb43: c6 40 3c 02 movb $0x2,0x3c(%eax) <== NOT EXECUTED ptimer->thread_id = _Thread_Executing->Object.id; 10eb47: a1 1c 7d 12 00 mov 0x127d1c,%eax <== NOT EXECUTED 10eb4c: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10eb4f: 89 43 38 mov %eax,0x38(%ebx) <== NOT EXECUTED if ( evp != NULL ) { 10eb52: 85 f6 test %esi,%esi <== NOT EXECUTED 10eb54: 74 11 je 10eb67 <== NOT EXECUTED ptimer->inf.sigev_notify = evp->sigev_notify; 10eb56: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10eb58: 89 43 40 mov %eax,0x40(%ebx) <== NOT EXECUTED ptimer->inf.sigev_signo = evp->sigev_signo; 10eb5b: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 10eb5e: 89 43 44 mov %eax,0x44(%ebx) <== NOT EXECUTED ptimer->inf.sigev_value = evp->sigev_value; 10eb61: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10eb64: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED } ptimer->overrun = 0; 10eb67: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) <== NOT EXECUTED ptimer->timer_data.it_value.tv_sec = 0; 10eb6e: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED ptimer->timer_data.it_value.tv_nsec = 0; 10eb75: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED ptimer->timer_data.it_interval.tv_sec = 0; 10eb7c: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED ptimer->timer_data.it_interval.tv_nsec = 0; 10eb83: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10eb8a: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10eb91: c7 43 2c 00 00 00 00 movl $0x0,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10eb98: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx) <== NOT EXECUTED * the heap 10eb9f: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED 10eba6: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10eba9: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10ebac: a1 fc 7f 12 00 mov 0x127ffc,%eax <== NOT EXECUTED 10ebb1: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10ebb4: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL ); _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0); *timerid = ptimer->Object.id; 10ebbb: 89 0f mov %ecx,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10ebbd: e8 c6 2a 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED 10ebc2: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10ebc4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ebc7: 5b pop %ebx <== NOT EXECUTED 10ebc8: 5e pop %esi <== NOT EXECUTED 10ebc9: 5f pop %edi <== NOT EXECUTED 10ebca: c9 leave <== NOT EXECUTED 10ebcb: c3 ret <== NOT EXECUTED 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 ); 10ebcc: e8 7b 79 00 00 call 11654c <__errno> <== NOT EXECUTED 10ebd1: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10ebd7: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED _Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0); *timerid = ptimer->Object.id; _Thread_Enable_dispatch(); return 0; } 10ebdc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ebdf: 5b pop %ebx <== NOT EXECUTED 10ebe0: 5e pop %esi <== NOT EXECUTED 10ebe1: 5f pop %edi <== NOT EXECUTED 10ebe2: c9 leave <== NOT EXECUTED 10ebe3: c3 ret <== NOT EXECUTED /* * Allocate a timer */ ptimer = _POSIX_Timer_Allocate(); if ( !ptimer ) { _Thread_Enable_dispatch(); 10ebe4: e8 9f 2a 00 00 call 111688 <_Thread_Enable_dispatch> <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EAGAIN ); 10ebe9: e8 5e 79 00 00 call 11654c <__errno> <== NOT EXECUTED 10ebee: c7 00 0b 00 00 00 movl $0xb,(%eax) <== NOT EXECUTED 10ebf4: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ebf9: eb c9 jmp 10ebc4 <== NOT EXECUTED 0010a314 : int timer_delete( timer_t timerid ) { 10a314: 55 push %ebp <== NOT EXECUTED 10a315: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a317: 53 push %ebx <== NOT EXECUTED 10a318: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size 10a31b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10a31e: 50 push %eax <== NOT EXECUTED 10a31f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10a322: 68 80 2e 12 00 push $0x122e80 <== NOT EXECUTED 10a327: e8 f4 22 00 00 call 10c620 <_Objects_Get> <== NOT EXECUTED 10a32c: 89 c3 mov %eax,%ebx <== NOT EXECUTED */ POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 10a32e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a331: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 10a334: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10a336: 74 18 je 10a350 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10a338: e8 df 7a 00 00 call 111e1c <__errno> <== NOT EXECUTED 10a33d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10a343: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 10a348: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a34b: c9 leave <== NOT EXECUTED 10a34c: c3 ret <== NOT EXECUTED 10a34d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { case OBJECTS_LOCAL: _Objects_Close( &_POSIX_Timer_Information, &ptimer->Object ); 10a350: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a353: 50 push %eax <== NOT EXECUTED 10a354: 68 80 2e 12 00 push $0x122e80 <== NOT EXECUTED 10a359: e8 4e 1e 00 00 call 10c1ac <_Objects_Close> <== NOT EXECUTED ptimer->state = POSIX_TIMER_STATE_FREE; 10a35e: c6 43 3c 01 movb $0x1,0x3c(%ebx) <== NOT EXECUTED (void) _Watchdog_Remove( &ptimer->Timer ); 10a362: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10a365: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10a368: e8 07 3c 00 00 call 10df74 <_Watchdog_Remove> <== NOT EXECUTED * @return This method returns the maximum memory available. If * unsuccessful, 0 will be returned. */ static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, 10a36d: 58 pop %eax <== NOT EXECUTED 10a36e: 5a pop %edx <== NOT EXECUTED 10a36f: 53 push %ebx <== NOT EXECUTED 10a370: 68 80 2e 12 00 push $0x122e80 <== NOT EXECUTED 10a375: e8 72 21 00 00 call 10c4ec <_Objects_Free> <== NOT EXECUTED _POSIX_Timer_Free( ptimer ); _Thread_Enable_dispatch(); 10a37a: e8 e5 2a 00 00 call 10ce64 <_Thread_Enable_dispatch> <== NOT EXECUTED 10a37f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a381: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10a384: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10a387: c9 leave <== NOT EXECUTED 10a388: c3 ret <== NOT EXECUTED 0010b4b8 : * its execution, _POSIX_Timer_TSR will have to set this counter to 0. */ int timer_getoverrun( timer_t timerid ) { 10b4b8: 55 push %ebp <== NOT EXECUTED 10b4b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4bb: 53 push %ebx <== NOT EXECUTED 10b4bc: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED * @return a status indicating success or the reason for failure */ bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size 10b4bf: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10b4c2: 50 push %eax <== NOT EXECUTED 10b4c3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b4c6: 68 c0 41 12 00 push $0x1241c0 <== NOT EXECUTED 10b4cb: e8 7c 22 00 00 call 10d74c <_Objects_Get> <== NOT EXECUTED int overrun; POSIX_Timer_Control *ptimer; Objects_Locations location; ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 10b4d0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b4d3: 8b 55 f8 mov -0x8(%ebp),%edx <== NOT EXECUTED 10b4d6: 85 d2 test %edx,%edx <== NOT EXECUTED 10b4d8: 74 1a je 10b4f4 <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b4da: e8 b9 76 00 00 call 112b98 <__errno> <== NOT EXECUTED 10b4df: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b4e5: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED } 10b4ea: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b4ec: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b4ef: c9 leave <== NOT EXECUTED 10b4f0: c3 ret <== NOT EXECUTED 10b4f1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { case OBJECTS_LOCAL: overrun = ptimer->overrun; 10b4f4: 8b 58 68 mov 0x68(%eax),%ebx <== NOT EXECUTED ptimer->overrun = 0; 10b4f7: c7 40 68 00 00 00 00 movl $0x0,0x68(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 10b4fe: e8 8d 2a 00 00 call 10df90 <_Thread_Enable_dispatch> <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b503: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b505: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b508: c9 leave <== NOT EXECUTED 10b509: c3 ret <== NOT EXECUTED 0010b50c : int timer_gettime( timer_t timerid, struct itimerspec *value ) { 10b50c: 55 push %ebp <== NOT EXECUTED 10b50d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b50f: 56 push %esi <== NOT EXECUTED 10b510: 53 push %ebx <== NOT EXECUTED 10b511: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10b514: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED POSIX_Timer_Control *ptimer; Objects_Locations location; struct timespec current_time; Watchdog_Interval left; if ( !value ) 10b517: 85 f6 test %esi,%esi <== NOT EXECUTED 10b519: 74 65 je 10b580 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); /* Reads the current time */ _TOD_Get( ¤t_time ); 10b51b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b51e: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10b521: 50 push %eax <== NOT EXECUTED 10b522: e8 b9 19 00 00 call 10cee0 <_TOD_Get> <== NOT EXECUTED 10b527: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10b52a: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10b52d: 50 push %eax <== NOT EXECUTED 10b52e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b531: 68 c0 41 12 00 push $0x1241c0 <== NOT EXECUTED 10b536: e8 11 22 00 00 call 10d74c <_Objects_Get> <== NOT EXECUTED 10b53b: 89 c3 mov %eax,%ebx <== NOT EXECUTED ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 10b53d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b540: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10b543: 85 c0 test %eax,%eax <== NOT EXECUTED 10b545: 75 39 jne 10b580 <== NOT EXECUTED case OBJECTS_LOCAL: /* Calculates the time left before the timer finishes */ left = 10b547: 8b 15 a4 3f 12 00 mov 0x123fa4,%edx <== NOT EXECUTED (ptimer->Timer.start_time + ptimer->Timer.initial) - /* expire */ _Watchdog_Ticks_since_boot; /* now */ _Timespec_From_ticks( left, &value->it_value ); 10b54d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b550: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED 10b553: 50 push %eax <== NOT EXECUTED 10b554: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10b557: 03 43 24 add 0x24(%ebx),%eax <== NOT EXECUTED 10b55a: 29 d0 sub %edx,%eax <== NOT EXECUTED 10b55c: 50 push %eax <== NOT EXECUTED 10b55d: e8 96 36 00 00 call 10ebf8 <_Timespec_From_ticks> <== NOT EXECUTED value->it_interval = ptimer->timer_data.it_interval; 10b562: 8b 53 54 mov 0x54(%ebx),%edx <== NOT EXECUTED 10b565: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED 10b568: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10b56b: 89 16 mov %edx,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10b56d: e8 1e 2a 00 00 call 10df90 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b572: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b574: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b577: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b57a: 5b pop %ebx <== NOT EXECUTED 10b57b: 5e pop %esi <== NOT EXECUTED 10b57c: c9 leave <== NOT EXECUTED 10b57d: c3 ret <== NOT EXECUTED 10b57e: 66 90 xchg %ax,%ax <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b580: e8 13 76 00 00 call 112b98 <__errno> <== NOT EXECUTED 10b585: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b58b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10b590: eb e5 jmp 10b577 <== NOT EXECUTED 0010b594 : timer_t timerid, int flags, const struct itimerspec *value, struct itimerspec *ovalue ) { 10b594: 55 push %ebp <== NOT EXECUTED 10b595: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b597: 57 push %edi <== NOT EXECUTED 10b598: 56 push %esi <== NOT EXECUTED 10b599: 53 push %ebx <== NOT EXECUTED 10b59a: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED Objects_Locations location; bool activated; uint32_t initial_period; struct itimerspec normalize; if ( !value ) 10b59d: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b5a0: 85 c0 test %eax,%eax <== NOT EXECUTED 10b5a2: 0f 84 04 01 00 00 je 10b6ac <== NOT EXECUTED 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 ) || 10b5a8: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b5ab: 81 78 0c ff c9 9a 3b cmpl $0x3b9ac9ff,0xc(%eax) <== NOT EXECUTED 10b5b2: 0f 87 f4 00 00 00 ja 10b6ac <== NOT EXECUTED 10b5b8: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10b5bb: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 10b5c0: 0f 87 e6 00 00 00 ja 10b6ac <== NOT EXECUTED 10b5c6: 85 c0 test %eax,%eax <== NOT EXECUTED 10b5c8: 0f 88 de 00 00 00 js 10b6ac <== NOT EXECUTED ( value->it_interval.tv_nsec < 0 )) { /* The number of nanoseconds is not correct */ rtems_set_errno_and_return_minus_one( EINVAL ); } if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { 10b5ce: 83 7d 0c 04 cmpl $0x4,0xc(%ebp) <== NOT EXECUTED 10b5d2: 0f 84 2c 01 00 00 je 10b704 <== NOT EXECUTED 10b5d8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b5db: 85 c0 test %eax,%eax <== NOT EXECUTED 10b5dd: 0f 85 c9 00 00 00 jne 10b6ac <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10b5e3: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 10b5e6: 89 45 b8 mov %eax,-0x48(%ebp) <== NOT EXECUTED 10b5e9: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10b5ee: 89 c7 mov %eax,%edi <== NOT EXECUTED 10b5f0: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10b5f3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10b5f5: 50 push %eax <== NOT EXECUTED 10b5f6: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b5f9: 50 push %eax <== NOT EXECUTED 10b5fa: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b5fd: 68 c0 41 12 00 push $0x1241c0 <== NOT EXECUTED 10b602: e8 45 21 00 00 call 10d74c <_Objects_Get> <== NOT EXECUTED 10b607: 89 c3 mov %eax,%ebx <== NOT EXECUTED * something with the structure of times of the timer: to stop, start * or start it again */ ptimer = _POSIX_Timer_Get( timerid, &location ); switch ( location ) { 10b609: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b60c: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 10b60f: 85 ff test %edi,%edi <== NOT EXECUTED 10b611: 0f 85 95 00 00 00 jne 10b6ac <== NOT EXECUTED case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) { 10b617: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 10b61a: 85 f6 test %esi,%esi <== NOT EXECUTED 10b61c: 75 0b jne 10b629 <== NOT EXECUTED 10b61e: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 10b621: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b623: 0f 84 9b 00 00 00 je 10b6c4 <== NOT EXECUTED _Thread_Enable_dispatch(); return 0; } /* Convert from seconds and nanoseconds to ticks */ ptimer->ticks = _Timespec_To_ticks( &value->it_interval ); 10b629: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b62c: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10b62f: e8 6c 36 00 00 call 10eca0 <_Timespec_To_ticks> <== NOT EXECUTED 10b634: 89 43 64 mov %eax,0x64(%ebx) <== NOT EXECUTED initial_period = _Timespec_To_ticks( &normalize.it_value ); 10b637: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10b63a: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 10b63d: e8 5e 36 00 00 call 10eca0 <_Timespec_To_ticks> <== NOT EXECUTED activated = _POSIX_Timer_Insert_helper( 10b642: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10b645: 68 60 b7 10 00 push $0x10b760 <== NOT EXECUTED 10b64a: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10b64d: 50 push %eax <== NOT EXECUTED 10b64e: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10b651: 50 push %eax <== NOT EXECUTED 10b652: e8 b5 5b 00 00 call 11120c <_POSIX_Timer_Insert_helper> <== NOT EXECUTED initial_period, ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { 10b657: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10b65a: 84 c0 test %al,%al <== NOT EXECUTED 10b65c: 0f 84 e2 00 00 00 je 10b744 <== NOT EXECUTED /* * The timer has been started and is running. So we return the * old ones in "ovalue" */ if ( ovalue ) 10b662: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10b665: 85 c0 test %eax,%eax <== NOT EXECUTED 10b667: 0f 84 e3 00 00 00 je 10b750 <== NOT EXECUTED *ovalue = ptimer->timer_data; 10b66d: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10b670: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10b675: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 10b678: 89 c6 mov %eax,%esi <== NOT EXECUTED 10b67a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED ptimer->timer_data = normalize; 10b67c: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10b681: 89 c7 mov %eax,%edi <== NOT EXECUTED 10b683: 8b 75 b8 mov -0x48(%ebp),%esi <== NOT EXECUTED 10b686: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* Indicate that the time is running */ ptimer->state = POSIX_TIMER_STATE_CREATE_RUN; 10b688: c6 43 3c 03 movb $0x3,0x3c(%ebx) <== NOT EXECUTED _TOD_Get( &ptimer->time ); 10b68c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b68f: 8d 43 6c lea 0x6c(%ebx),%eax <== NOT EXECUTED 10b692: 50 push %eax <== NOT EXECUTED 10b693: e8 48 18 00 00 call 10cee0 <_TOD_Get> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b698: e8 f3 28 00 00 call 10df90 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b69d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b69f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); } 10b6a2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b6a5: 5b pop %ebx <== NOT EXECUTED 10b6a6: 5e pop %esi <== NOT EXECUTED 10b6a7: 5f pop %edi <== NOT EXECUTED 10b6a8: c9 leave <== NOT EXECUTED 10b6a9: c3 ret <== NOT EXECUTED 10b6aa: 66 90 xchg %ax,%ax <== NOT EXECUTED #endif case OBJECTS_ERROR: break; } rtems_set_errno_and_return_minus_one( EINVAL ); 10b6ac: e8 e7 74 00 00 call 112b98 <__errno> <== NOT EXECUTED 10b6b1: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10b6b7: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 10b6bc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b6bf: 5b pop %ebx <== NOT EXECUTED 10b6c0: 5e pop %esi <== NOT EXECUTED 10b6c1: 5f pop %edi <== NOT EXECUTED 10b6c2: c9 leave <== NOT EXECUTED 10b6c3: c3 ret <== NOT EXECUTED case OBJECTS_LOCAL: /* First, it verifies if the timer must be stopped */ if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) { /* Stop the timer */ (void) _Watchdog_Remove( &ptimer->Timer ); 10b6c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b6c7: 8d 40 10 lea 0x10(%eax),%eax <== NOT EXECUTED 10b6ca: 50 push %eax <== NOT EXECUTED 10b6cb: e8 0c 3a 00 00 call 10f0dc <_Watchdog_Remove> <== NOT EXECUTED /* The old data of the timer are returned */ if ( ovalue ) 10b6d0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b6d3: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10b6d6: 85 d2 test %edx,%edx <== NOT EXECUTED 10b6d8: 74 7e je 10b758 <== NOT EXECUTED *ovalue = ptimer->timer_data; 10b6da: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10b6dd: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10b6e2: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 10b6e5: 89 c6 mov %eax,%esi <== NOT EXECUTED 10b6e7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* The new data are set */ ptimer->timer_data = normalize; 10b6e9: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10b6ee: 89 c7 mov %eax,%edi <== NOT EXECUTED 10b6f0: 8b 75 b8 mov -0x48(%ebp),%esi <== NOT EXECUTED 10b6f3: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* Indicates that the timer is created and stopped */ ptimer->state = POSIX_TIMER_STATE_CREATE_STOP; 10b6f5: c6 43 3c 04 movb $0x4,0x3c(%ebx) <== NOT EXECUTED /* Returns with success */ _Thread_Enable_dispatch(); 10b6f9: e8 92 28 00 00 call 10df90 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b6fe: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b700: eb ba jmp 10b6bc <== NOT EXECUTED 10b702: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) { rtems_set_errno_and_return_minus_one( EINVAL ); } normalize = *value; 10b704: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED 10b707: 89 75 b8 mov %esi,-0x48(%ebp) <== NOT EXECUTED 10b70a: 89 f7 mov %esi,%edi <== NOT EXECUTED 10b70c: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10b70f: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10b712: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* Convert absolute to relative time */ if (flags == TIMER_ABSTIME) { /* Check for seconds in the past */ if ( _Timespec_Greater_than( &_TOD_Now, &normalize.it_value ) ) 10b714: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b717: 8d 5d e8 lea -0x18(%ebp),%ebx <== NOT EXECUTED 10b71a: 53 push %ebx <== NOT EXECUTED 10b71b: 68 cc 3e 12 00 push $0x123ecc <== NOT EXECUTED 10b720: e8 1b 35 00 00 call 10ec40 <_Timespec_Greater_than> <== NOT EXECUTED 10b725: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b728: 84 c0 test %al,%al <== NOT EXECUTED 10b72a: 75 80 jne 10b6ac <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); _Timespec_Subtract( &_TOD_Now, &normalize.it_value, &normalize.it_value ); 10b72c: 50 push %eax <== NOT EXECUTED 10b72d: 53 push %ebx <== NOT EXECUTED 10b72e: 53 push %ebx <== NOT EXECUTED 10b72f: 68 cc 3e 12 00 push $0x123ecc <== NOT EXECUTED 10b734: e8 2b 35 00 00 call 10ec64 <_Timespec_Subtract> <== NOT EXECUTED 10b739: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b73c: e9 b4 fe ff ff jmp 10b5f5 <== NOT EXECUTED 10b741: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ptimer->Object.id, _POSIX_Timer_TSR, ptimer ); if ( !activated ) { _Thread_Enable_dispatch(); 10b744: e8 47 28 00 00 call 10df90 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b749: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b74b: e9 6c ff ff ff jmp 10b6bc <== NOT EXECUTED 10b750: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10b753: e9 24 ff ff ff jmp 10b67c <== NOT EXECUTED 10b758: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10b75b: eb 8c jmp 10b6e9 <== NOT EXECUTED 0010c758 : int truncate( const char *path, off_t length ) { 10c758: 55 push %ebp <== NOT EXECUTED 10c759: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c75b: 56 push %esi <== NOT EXECUTED 10c75c: 53 push %ebx <== NOT EXECUTED int status; int fd; fd = open( path, O_WRONLY ); 10c75d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c760: 6a 01 push $0x1 <== NOT EXECUTED 10c762: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c765: e8 8a da ff ff call 10a1f4 <== NOT EXECUTED 10c76a: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( fd == -1 ) 10c76c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c76f: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10c772: 74 24 je 10c798 <== NOT EXECUTED return -1; status = ftruncate( fd, length ); 10c774: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c777: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c77a: 50 push %eax <== NOT EXECUTED 10c77b: e8 e8 4e 00 00 call 111668 <== NOT EXECUTED 10c780: 89 c6 mov %eax,%esi <== NOT EXECUTED (void) close( fd ); 10c782: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10c785: e8 9e c9 ff ff call 109128 <== NOT EXECUTED 10c78a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return status; } 10c78d: 89 f0 mov %esi,%eax <== NOT EXECUTED 10c78f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c792: 5b pop %ebx <== NOT EXECUTED 10c793: 5e pop %esi <== NOT EXECUTED 10c794: c9 leave <== NOT EXECUTED 10c795: c3 ret <== NOT EXECUTED 10c796: 66 90 xchg %ax,%ax <== NOT EXECUTED { int status; int fd; fd = open( path, O_WRONLY ); if ( fd == -1 ) 10c798: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED status = ftruncate( fd, length ); (void) close( fd ); return status; } 10c79d: 89 f0 mov %esi,%eax <== NOT EXECUTED 10c79f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c7a2: 5b pop %ebx <== NOT EXECUTED 10c7a3: 5e pop %esi <== NOT EXECUTED 10c7a4: c9 leave <== NOT EXECUTED 10c7a5: c3 ret <== NOT EXECUTED 001255d4 : */ char *ttyname( int fd ) { 1255d4: 55 push %ebp <== NOT EXECUTED 1255d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1255d7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED if ( !ttyname_r( fd, ttyname_buf, sizeof(ttyname_buf) ) ) 1255da: 68 06 04 00 00 push $0x406 <== NOT EXECUTED 1255df: 68 00 bb 14 00 push $0x14bb00 <== NOT EXECUTED 1255e4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1255e7: e8 f4 fe ff ff call 1254e0 <== NOT EXECUTED 1255ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1255ef: 85 c0 test %eax,%eax <== NOT EXECUTED 1255f1: 75 09 jne 1255fc <== NOT EXECUTED 1255f3: b8 00 bb 14 00 mov $0x14bb00,%eax <== NOT EXECUTED return ttyname_buf; return NULL; } 1255f8: c9 leave <== NOT EXECUTED 1255f9: c3 ret <== NOT EXECUTED 1255fa: 66 90 xchg %ax,%ax <== NOT EXECUTED char *ttyname( int fd ) { if ( !ttyname_r( fd, ttyname_buf, sizeof(ttyname_buf) ) ) 1255fc: 31 c0 xor %eax,%eax <== NOT EXECUTED return ttyname_buf; return NULL; } 1255fe: c9 leave <== NOT EXECUTED 1255ff: c3 ret <== NOT EXECUTED 001254e0 : int ttyname_r( int fd, char *name, size_t namesize ) { 1254e0: 55 push %ebp <== NOT EXECUTED 1254e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1254e3: 57 push %edi <== NOT EXECUTED 1254e4: 56 push %esi <== NOT EXECUTED 1254e5: 53 push %ebx <== NOT EXECUTED 1254e6: 81 ec d4 00 00 00 sub $0xd4,%esp <== NOT EXECUTED 1254ec: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED DIR *dp; struct stat dsb; char *rval; /* Must be a terminal. */ if (tcgetattr (fd, &tty) < 0) 1254ef: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 1254f2: 50 push %eax <== NOT EXECUTED 1254f3: 53 push %ebx <== NOT EXECUTED 1254f4: e8 77 ff ff ff call 125470 <== NOT EXECUTED 1254f9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1254fc: 85 c0 test %eax,%eax <== NOT EXECUTED 1254fe: 78 23 js 125523 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EBADF); /* Must be a character device. */ if (fstat (fd, &sb) || !S_ISCHR (sb.st_mode)) 125500: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 125503: 8d 45 84 lea -0x7c(%ebp),%eax <== NOT EXECUTED 125506: 50 push %eax <== NOT EXECUTED 125507: 53 push %ebx <== NOT EXECUTED 125508: e8 db e3 ff ff call 1238e8 <== NOT EXECUTED 12550d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125510: 85 c0 test %eax,%eax <== NOT EXECUTED 125512: 75 0f jne 125523 <== NOT EXECUTED 125514: 8b 45 90 mov -0x70(%ebp),%eax <== NOT EXECUTED 125517: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 12551c: 3d 00 20 00 00 cmp $0x2000,%eax <== NOT EXECUTED 125521: 74 19 je 12553c <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EBADF); if ((dp = opendir (_PATH_DEV)) == NULL) rtems_set_errno_and_return_minus_one(EBADF); 125523: e8 2c c3 00 00 call 131854 <__errno> <== NOT EXECUTED 125528: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 12552e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED rval = name; break; } (void) closedir (dp); return 0; } 125533: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 125536: 5b pop %ebx <== NOT EXECUTED 125537: 5e pop %esi <== NOT EXECUTED 125538: 5f pop %edi <== NOT EXECUTED 125539: c9 leave <== NOT EXECUTED 12553a: c3 ret <== NOT EXECUTED 12553b: 90 nop <== 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) 12553c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12553f: 68 9f 51 14 00 push $0x14519f <== NOT EXECUTED 125544: e8 cb f8 ff ff call 124e14 <== NOT EXECUTED 125549: 89 c3 mov %eax,%ebx <== NOT EXECUTED 12554b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12554e: 85 c0 test %eax,%eax <== NOT EXECUTED 125550: 74 d1 je 125523 <== 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); 125552: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 125555: 83 c6 05 add $0x5,%esi <== NOT EXECUTED if (stat (name, &dsb) || sb.st_dev != dsb.st_dev || 125558: 8d bd 38 ff ff ff lea -0xc8(%ebp),%edi <== NOT EXECUTED 12555e: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EBADF); if ((dp = opendir (_PATH_DEV)) == NULL) rtems_set_errno_and_return_minus_one(EBADF); for (rval = NULL; (dirp = readdir (dp)) != NULL ;) 125560: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125563: 53 push %ebx <== NOT EXECUTED 125564: e8 53 fb ff ff call 1250bc <== NOT EXECUTED 125569: 89 c2 mov %eax,%edx <== NOT EXECUTED 12556b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12556e: 85 c0 test %eax,%eax <== NOT EXECUTED 125570: 74 4a je 1255bc <== NOT EXECUTED { if (dirp->d_ino != sb.st_ino) 125572: 8b 02 mov (%edx),%eax <== NOT EXECUTED 125574: 3b 45 8c cmp -0x74(%ebp),%eax <== NOT EXECUTED 125577: 75 e7 jne 125560 <== NOT EXECUTED continue; strcpy (name + sizeof (_PATH_DEV) - 1, dirp->d_name); 125579: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12557c: 8d 42 0c lea 0xc(%edx),%eax <== NOT EXECUTED 12557f: 50 push %eax <== NOT EXECUTED 125580: 56 push %esi <== NOT EXECUTED 125581: e8 7e 07 01 00 call 135d04 <== NOT EXECUTED if (stat (name, &dsb) || sb.st_dev != dsb.st_dev || 125586: 58 pop %eax <== NOT EXECUTED 125587: 5a pop %edx <== NOT EXECUTED 125588: 57 push %edi <== NOT EXECUTED 125589: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 12558c: e8 bf 73 fe ff call 10c950 <== NOT EXECUTED 125591: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125594: 85 c0 test %eax,%eax <== NOT EXECUTED 125596: 75 c8 jne 125560 <== NOT EXECUTED 125598: 8b 55 84 mov -0x7c(%ebp),%edx <== NOT EXECUTED 12559b: 8b 45 88 mov -0x78(%ebp),%eax <== NOT EXECUTED 12559e: 33 85 3c ff ff ff xor -0xc4(%ebp),%eax <== NOT EXECUTED 1255a4: 33 95 38 ff ff ff xor -0xc8(%ebp),%edx <== NOT EXECUTED 1255aa: 09 d0 or %edx,%eax <== NOT EXECUTED 1255ac: 75 b2 jne 125560 <== NOT EXECUTED 1255ae: 8b 45 8c mov -0x74(%ebp),%eax <== NOT EXECUTED 1255b1: 3b 85 40 ff ff ff cmp -0xc0(%ebp),%eax <== NOT EXECUTED 1255b7: 75 a7 jne 125560 <== NOT EXECUTED 1255b9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED sb.st_ino != dsb.st_ino) continue; rval = name; break; } (void) closedir (dp); 1255bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1255bf: 53 push %ebx <== NOT EXECUTED 1255c0: e8 fb a1 00 00 call 12f7c0 <== NOT EXECUTED 1255c5: 31 c0 xor %eax,%eax <== NOT EXECUTED 1255c7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 1255ca: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1255cd: 5b pop %ebx <== NOT EXECUTED 1255ce: 5e pop %esi <== NOT EXECUTED 1255cf: 5f pop %edi <== NOT EXECUTED 1255d0: c9 leave <== NOT EXECUTED 1255d1: c3 ret <== NOT EXECUTED 00109f50 : useconds_t ualarm( useconds_t useconds, useconds_t interval ) { 109f50: 55 push %ebp <== NOT EXECUTED 109f51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109f53: 57 push %edi <== NOT EXECUTED 109f54: 56 push %esi <== NOT EXECUTED 109f55: 53 push %ebx <== NOT EXECUTED 109f56: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 109f59: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED /* * Initialize the timer used to implement alarm(). */ if ( !the_timer->routine ) { 109f5c: 8b 0d bc 21 12 00 mov 0x1221bc,%ecx <== NOT EXECUTED 109f62: 85 c9 test %ecx,%ecx <== NOT EXECUTED 109f64: 0f 84 ea 00 00 00 je 10a054 <== NOT EXECUTED _Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL ); } else { switch ( _Watchdog_Remove( the_timer ) ) { 109f6a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109f6d: 68 a0 21 12 00 push $0x1221a0 <== NOT EXECUTED 109f72: e8 dd 3a 00 00 call 10da54 <_Watchdog_Remove> <== NOT EXECUTED 109f77: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109f7a: 83 e8 02 sub $0x2,%eax <== NOT EXECUTED 109f7d: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 109f80: 76 72 jbe 109ff4 <== NOT EXECUTED 109f82: 31 ff xor %edi,%edi <== NOT EXECUTED /* * If useconds is non-zero, then the caller wants to schedule * the alarm repeatedly at that interval. If the interval is * less than a single clock tick, then fudge it to a clock tick. */ if ( useconds ) { 109f84: 85 f6 test %esi,%esi <== NOT EXECUTED 109f86: 74 62 je 109fea <== NOT EXECUTED Watchdog_Interval ticks; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 109f88: ba 83 de 1b 43 mov $0x431bde83,%edx <== NOT EXECUTED 109f8d: 89 f0 mov %esi,%eax <== NOT EXECUTED 109f8f: f7 e2 mul %edx <== NOT EXECUTED 109f91: c1 ea 12 shr $0x12,%edx <== NOT EXECUTED 109f94: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 109f97: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 109f9a: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 109f9d: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 109fa0: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 109fa3: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 109fa6: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 109fa9: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 109fac: 29 d6 sub %edx,%esi <== NOT EXECUTED 109fae: 8d 04 b6 lea (%esi,%esi,4),%eax <== NOT EXECUTED 109fb1: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 109fb4: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 109fb7: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 109fba: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED ticks = _Timespec_To_ticks( &tp ); 109fbd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109fc0: 8d 5d e8 lea -0x18(%ebp),%ebx <== NOT EXECUTED 109fc3: 53 push %ebx <== NOT EXECUTED 109fc4: e8 0f 36 00 00 call 10d5d8 <_Timespec_To_ticks> <== NOT EXECUTED if ( ticks == 0 ) ticks = 1; _Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) ); 109fc9: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 109fcc: e8 07 36 00 00 call 10d5d8 <_Timespec_To_ticks> <== NOT EXECUTED * @param[in] size points to a user area to return the size in * @return TRUE if successfully able to determine the size, FALSE otherwise * @return *size filled in with the size of the user area for this block */ bool _Protected_heap_Get_block_size( Heap_Control *the_heap, 109fd1: a3 ac 21 12 00 mov %eax,0x1221ac <== NOT EXECUTED void *starting_address, size_t *size 109fd6: 58 pop %eax <== NOT EXECUTED 109fd7: 5a pop %edx <== NOT EXECUTED 109fd8: 68 a0 21 12 00 push $0x1221a0 <== NOT EXECUTED 109fdd: 68 7c 23 12 00 push $0x12237c <== NOT EXECUTED 109fe2: e8 3d 39 00 00 call 10d924 <_Watchdog_Insert> <== NOT EXECUTED 109fe7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return remaining; } 109fea: 89 f8 mov %edi,%eax <== NOT EXECUTED 109fec: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 109fef: 5b pop %ebx <== NOT EXECUTED 109ff0: 5e pop %esi <== NOT EXECUTED 109ff1: 5f pop %edi <== NOT EXECUTED 109ff2: c9 leave <== NOT EXECUTED 109ff3: c3 ret <== NOT EXECUTED * boot. Since alarm() is dealing in seconds, we must account for * this. */ ticks = the_timer->initial; ticks -= (the_timer->stop_time - the_timer->start_time); 109ff4: a1 b4 21 12 00 mov 0x1221b4,%eax <== NOT EXECUTED 109ff9: 03 05 ac 21 12 00 add 0x1221ac,%eax <== NOT EXECUTED /* remaining is now in ticks */ _Timespec_From_ticks( ticks, &tp ); 109fff: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a002: 8d 55 e8 lea -0x18(%ebp),%edx <== NOT EXECUTED 10a005: 52 push %edx <== NOT EXECUTED 10a006: 2b 05 b8 21 12 00 sub 0x1221b8,%eax <== NOT EXECUTED 10a00c: 50 push %eax <== NOT EXECUTED 10a00d: e8 42 35 00 00 call 10d554 <_Timespec_From_ticks> <== NOT EXECUTED remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND; 10a012: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10a015: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10a018: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10a01b: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10a01e: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10a021: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10a024: 8d 3c 80 lea (%eax,%eax,4),%edi <== NOT EXECUTED 10a027: c1 e7 06 shl $0x6,%edi <== NOT EXECUTED remaining += tp.tv_nsec / 1000; 10a02a: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 10a02d: b9 d3 4d 62 10 mov $0x10624dd3,%ecx <== NOT EXECUTED 10a032: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10a034: f7 e9 imul %ecx <== NOT EXECUTED 10a036: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED 10a039: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED 10a03c: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10a03f: c1 fa 06 sar $0x6,%edx <== NOT EXECUTED 10a042: c1 fb 1f sar $0x1f,%ebx <== NOT EXECUTED 10a045: 29 da sub %ebx,%edx <== NOT EXECUTED 10a047: 8d 3c 3a lea (%edx,%edi,1),%edi <== NOT EXECUTED 10a04a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a04d: e9 32 ff ff ff jmp 109f84 <== NOT EXECUTED 10a052: 66 90 xchg %ax,%ax <== NOT EXECUTED * This routine initializes @a the_heap record to manage the * contiguous heap of @a size bytes which starts at @a starting_address. * Blocks of memory are allocated from the heap in multiples of * @a page_size byte units. If @a page_size is 0 or is not multiple of * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. * 10a054: c7 05 a8 21 12 00 00 movl $0x0,0x1221a8 <== NOT EXECUTED 10a05b: 00 00 00 <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10a05e: c7 05 bc 21 12 00 84 movl $0x10a084,0x1221bc <== NOT EXECUTED 10a065: a0 10 00 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10a068: c7 05 c0 21 12 00 00 movl $0x0,0x1221c0 <== NOT EXECUTED 10a06f: 00 00 00 <== NOT EXECUTED * the heap 10a072: c7 05 c4 21 12 00 00 movl $0x0,0x1221c4 <== NOT EXECUTED 10a079: 00 00 00 <== NOT EXECUTED 10a07c: 31 ff xor %edi,%edi <== NOT EXECUTED 10a07e: e9 01 ff ff ff jmp 109f84 <== NOT EXECUTED 00125600 : #include mode_t umask( mode_t cmask ) { 125600: 55 push %ebp <== NOT EXECUTED 125601: 89 e5 mov %esp,%ebp <== NOT EXECUTED mode_t old_mask; old_mask = rtems_filesystem_umask; 125603: 8b 15 ec ba 14 00 mov 0x14baec,%edx <== NOT EXECUTED 125609: 8b 42 24 mov 0x24(%edx),%eax <== NOT EXECUTED rtems_filesystem_umask = cmask; 12560c: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 12560f: 89 4a 24 mov %ecx,0x24(%edx) <== NOT EXECUTED return old_mask; } 125612: c9 leave <== NOT EXECUTED 125613: c3 ret <== NOT EXECUTED 0010a9d4 : */ int uname( struct utsname *name ) { 10a9d4: 55 push %ebp <== NOT EXECUTED 10a9d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a9d7: 53 push %ebx <== NOT EXECUTED 10a9d8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10a9db: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED release = 5.3 version = Generic_101318-12 machine = sun4m */ if ( !name ) 10a9de: 85 db test %ebx,%ebx <== NOT EXECUTED 10a9e0: 74 53 je 10aa35 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); strcpy( name->sysname, "RTEMS" ); 10a9e2: c7 03 52 54 45 4d movl $0x4d455452,(%ebx) <== NOT EXECUTED 10a9e8: 66 c7 43 04 53 00 movw $0x53,0x4(%ebx) <== NOT EXECUTED sprintf( name->nodename, "Node %" PRId16, _Objects_Local_node ); 10a9ee: 50 push %eax <== NOT EXECUTED 10a9ef: 6a 01 push $0x1 <== NOT EXECUTED 10a9f1: 68 63 c9 11 00 push $0x11c963 <== NOT EXECUTED 10a9f6: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED 10a9f9: 50 push %eax <== NOT EXECUTED 10a9fa: e8 69 90 00 00 call 113a68 <== NOT EXECUTED strcpy( name->release, RTEMS_VERSION ); 10a9ff: c7 43 40 34 2e 39 2e movl $0x2e392e34,0x40(%ebx) <== NOT EXECUTED 10aa06: 66 c7 43 44 34 00 movw $0x34,0x44(%ebx) <== NOT EXECUTED strcpy( name->version, "" ); 10aa0c: c6 43 60 00 movb $0x0,0x60(%ebx) <== NOT EXECUTED sprintf( name->machine, "%s/%s", CPU_NAME, CPU_MODEL_NAME ); 10aa10: 68 6b c9 11 00 push $0x11c96b <== NOT EXECUTED 10aa15: 68 7a c9 11 00 push $0x11c97a <== NOT EXECUTED 10aa1a: 68 85 c9 11 00 push $0x11c985 <== NOT EXECUTED 10aa1f: 8d 83 80 00 00 00 lea 0x80(%ebx),%eax <== NOT EXECUTED 10aa25: 50 push %eax <== NOT EXECUTED 10aa26: e8 3d 90 00 00 call 113a68 <== NOT EXECUTED 10aa2b: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aa2d: 83 c4 20 add $0x20,%esp <== NOT EXECUTED return 0; } 10aa30: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aa33: c9 leave <== NOT EXECUTED 10aa34: c3 ret <== NOT EXECUTED version = Generic_101318-12 machine = sun4m */ if ( !name ) rtems_set_errno_and_return_minus_one( EFAULT ); 10aa35: e8 a6 7b 00 00 call 1125e0 <__errno> <== NOT EXECUTED 10aa3a: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 10aa40: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10aa45: eb e9 jmp 10aa30 <== NOT EXECUTED 0010e6e4 : #include int unlink( const char *path ) { 10e6e4: 55 push %ebp <== NOT EXECUTED 10e6e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e6e7: 56 push %esi <== NOT EXECUTED 10e6e8: 53 push %ebx <== NOT EXECUTED 10e6e9: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED /* * Get the node to be unlinked. */ result = rtems_filesystem_evaluate_path( path, 0, &loc, false ); 10e6ec: 6a 00 push $0x0 <== NOT EXECUTED 10e6ee: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 10e6f1: 56 push %esi <== NOT EXECUTED 10e6f2: 6a 00 push $0x0 <== NOT EXECUTED 10e6f4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10e6f7: e8 30 cb ff ff call 10b22c <== NOT EXECUTED if ( result != 0 ) 10e6fc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e6ff: 85 c0 test %eax,%eax <== NOT EXECUTED 10e701: 74 11 je 10e714 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->unlink_h)( &loc ); rtems_filesystem_freenode( &loc ); 10e703: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED return result; } 10e708: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e70a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e70d: 5b pop %ebx <== NOT EXECUTED 10e70e: 5e pop %esi <== NOT EXECUTED 10e70f: c9 leave <== NOT EXECUTED 10e710: c3 ret <== NOT EXECUTED 10e711: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED result = rtems_filesystem_evaluate_path( path, 0, &loc, false ); if ( result != 0 ) return -1; result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc ); 10e714: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e717: 56 push %esi <== NOT EXECUTED 10e718: 6a 02 push $0x2 <== NOT EXECUTED 10e71a: e8 75 ca ff ff call 10b194 <== NOT EXECUTED if (result != 0 && errno != ENOTSUP) { 10e71f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e722: 85 c0 test %eax,%eax <== NOT EXECUTED 10e724: 75 56 jne 10e77c <== NOT EXECUTED rtems_filesystem_freenode( &loc ); return -1; } if ( !loc.ops->node_type_h ) { 10e726: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10e729: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10e72c: 85 c0 test %eax,%eax <== NOT EXECUTED 10e72e: 0f 84 80 00 00 00 je 10e7b4 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) { 10e734: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e737: 56 push %esi <== NOT EXECUTED 10e738: ff d0 call *%eax <== NOT EXECUTED 10e73a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e73d: 48 dec %eax <== NOT EXECUTED 10e73e: 0f 84 95 00 00 00 je 10e7d9 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( EISDIR ); } if ( !loc.ops->unlink_h ) { 10e744: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10e747: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10e74a: 85 c0 test %eax,%eax <== NOT EXECUTED 10e74c: 74 66 je 10e7b4 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->unlink_h)( &loc ); 10e74e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e751: 56 push %esi <== NOT EXECUTED 10e752: ff d0 call *%eax <== NOT EXECUTED 10e754: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 10e756: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10e759: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e75c: 85 c0 test %eax,%eax <== NOT EXECUTED 10e75e: 74 a8 je 10e708 <== NOT EXECUTED 10e760: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10e763: 85 c0 test %eax,%eax <== NOT EXECUTED 10e765: 74 a1 je 10e708 <== NOT EXECUTED 10e767: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e76a: 56 push %esi <== NOT EXECUTED 10e76b: ff d0 call *%eax <== NOT EXECUTED 10e76d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 10e770: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e772: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e775: 5b pop %ebx <== NOT EXECUTED 10e776: 5e pop %esi <== NOT EXECUTED 10e777: c9 leave <== NOT EXECUTED 10e778: c3 ret <== NOT EXECUTED 10e779: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 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) { 10e77c: e8 d3 30 02 00 call 131854 <__errno> <== NOT EXECUTED 10e781: 81 38 86 00 00 00 cmpl $0x86,(%eax) <== NOT EXECUTED 10e787: 74 9d je 10e726 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 10e789: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10e78c: 85 c0 test %eax,%eax <== NOT EXECUTED 10e78e: 0f 84 6f ff ff ff je 10e703 <== NOT EXECUTED 10e794: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10e797: 85 c0 test %eax,%eax <== NOT EXECUTED 10e799: 0f 84 64 ff ff ff je 10e703 <== NOT EXECUTED 10e79f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e7a2: 56 push %esi <== NOT EXECUTED 10e7a3: ff d0 call *%eax <== NOT EXECUTED 10e7a5: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10e7aa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e7ad: e9 56 ff ff ff jmp 10e708 <== NOT EXECUTED 10e7b2: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( EISDIR ); } if ( !loc.ops->unlink_h ) { rtems_filesystem_freenode( &loc ); 10e7b4: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 10e7b7: 85 c0 test %eax,%eax <== NOT EXECUTED 10e7b9: 74 09 je 10e7c4 <== NOT EXECUTED 10e7bb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e7be: 56 push %esi <== NOT EXECUTED 10e7bf: ff d0 call *%eax <== NOT EXECUTED 10e7c1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 10e7c4: e8 8b 30 02 00 call 131854 <__errno> <== NOT EXECUTED 10e7c9: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10e7cf: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10e7d4: e9 2f ff ff ff jmp 10e708 <== 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 ); 10e7d9: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10e7dc: 85 c0 test %eax,%eax <== NOT EXECUTED 10e7de: 74 10 je 10e7f0 <== NOT EXECUTED 10e7e0: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10e7e3: 85 c0 test %eax,%eax <== NOT EXECUTED 10e7e5: 74 09 je 10e7f0 <== NOT EXECUTED 10e7e7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e7ea: 56 push %esi <== NOT EXECUTED 10e7eb: ff d0 call *%eax <== NOT EXECUTED 10e7ed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EISDIR ); 10e7f0: e8 5f 30 02 00 call 131854 <__errno> <== NOT EXECUTED 10e7f5: c7 00 15 00 00 00 movl $0x15,(%eax) <== NOT EXECUTED 10e7fb: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10e800: e9 03 ff ff ff jmp 10e708 <== NOT EXECUTED 0012565c : */ int unmount( const char *path ) { 12565c: 55 push %ebp <== NOT EXECUTED 12565d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12565f: 56 push %esi <== NOT EXECUTED 125660: 53 push %ebx <== NOT EXECUTED 125661: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED * The root node of the mounted filesytem. * The node for the directory that the fileystem is mounted on. * The mount entry that is being refered to. */ if ( rtems_filesystem_evaluate_path( path, 0x0, &loc, true ) ) 125664: 6a 01 push $0x1 <== NOT EXECUTED 125666: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 125669: 56 push %esi <== NOT EXECUTED 12566a: 6a 00 push $0x0 <== NOT EXECUTED 12566c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12566f: e8 b8 5b fe ff call 10b22c <== NOT EXECUTED 125674: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125677: 85 c0 test %eax,%eax <== NOT EXECUTED 125679: 0f 85 90 00 00 00 jne 12570f <== NOT EXECUTED return -1; mt_entry = loc.mt_entry; 12567f: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED /* * Verify this is the root node for the file system to be unmounted. */ if ( !rtems_filesystem_nodes_equal( fs_root_loc, &loc) ){ 125682: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 125685: 3b 45 e8 cmp -0x18(%ebp),%eax <== NOT EXECUTED 125688: 0f 85 a6 00 00 00 jne 125734 <== NOT EXECUTED /* * Free the loc node and just use the nodes from the mt_entry . */ rtems_filesystem_freenode( &loc ); 12568e: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 125691: 85 c0 test %eax,%eax <== NOT EXECUTED 125693: 74 10 je 1256a5 <== NOT EXECUTED 125695: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 125698: 85 c0 test %eax,%eax <== NOT EXECUTED 12569a: 74 09 je 1256a5 <== NOT EXECUTED 12569c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12569f: 56 push %esi <== NOT EXECUTED 1256a0: ff d0 call *%eax <== NOT EXECUTED 1256a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Verify Unmount is supported by both filesystems. */ if ( !fs_mount_loc->ops->unmount_h ) 1256a5: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 1256a8: 8b 50 28 mov 0x28(%eax),%edx <== NOT EXECUTED 1256ab: 85 d2 test %edx,%edx <== NOT EXECUTED 1256ad: 0f 84 1d 01 00 00 je 1257d0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( !fs_root_loc->ops->fsunmount_me_h ) 1256b3: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 1256b6: 8b 40 2c mov 0x2c(%eax),%eax <== NOT EXECUTED 1256b9: 85 c0 test %eax,%eax <== NOT EXECUTED 1256bb: 0f 84 0f 01 00 00 je 1257d0 <== NOT EXECUTED * that made the current node thread based instead * of system based? I thought it was but it doesn't * look like it in this version. */ if ( rtems_filesystem_current.mt_entry == mt_entry ) 1256c1: a1 ec ba 14 00 mov 0x14baec,%eax <== NOT EXECUTED 1256c6: 39 58 10 cmp %ebx,0x10(%eax) <== NOT EXECUTED 1256c9: 74 51 je 12571c <== NOT EXECUTED /* * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; 1256cb: a1 0c 1e 16 00 mov 0x161e0c,%eax <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment 1256d0: b9 10 1e 16 00 mov $0x161e10,%ecx <== NOT EXECUTED !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); 1256d5: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 1256d7: 74 16 je 1256ef <== 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 ) { 1256d9: 8b 53 24 mov 0x24(%ebx),%edx <== NOT EXECUTED 1256dc: 39 50 14 cmp %edx,0x14(%eax) <== NOT EXECUTED 1256df: 75 08 jne 1256e9 <== NOT EXECUTED 1256e1: eb 39 jmp 12571c <== NOT EXECUTED 1256e3: 90 nop <== NOT EXECUTED 1256e4: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 1256e7: 74 33 je 12571c <== NOT EXECUTED * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); the_node = the_node->next ) { 1256e9: 8b 00 mov (%eax),%eax <== NOT EXECUTED * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); 1256eb: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 1256ed: 75 f5 jne 1256e4 <== NOT EXECUTED * 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 ) 1256ef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1256f2: 53 push %ebx <== NOT EXECUTED 1256f3: e8 d0 5e fe ff call 10b5c8 <== NOT EXECUTED 1256f8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1256fb: 48 dec %eax <== NOT EXECUTED 1256fc: 74 1e je 12571c <== NOT EXECUTED * 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 ) 1256fe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125701: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 125704: 53 push %ebx <== NOT EXECUTED 125705: ff 50 28 call *0x28(%eax) <== NOT EXECUTED 125708: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12570b: 85 c0 test %eax,%eax <== NOT EXECUTED 12570d: 74 55 je 125764 <== NOT EXECUTED */ rtems_filesystem_freenode( fs_mount_loc ); free( mt_entry ); return 0; 12570f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 125714: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 125717: 5b pop %ebx <== NOT EXECUTED 125718: 5e pop %esi <== NOT EXECUTED 125719: c9 leave <== NOT EXECUTED 12571a: c3 ret <== NOT EXECUTED 12571b: 90 nop <== NOT EXECUTED * 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 ); 12571c: e8 33 c1 00 00 call 131854 <__errno> <== NOT EXECUTED 125721: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED 125727: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED rtems_filesystem_freenode( fs_mount_loc ); free( mt_entry ); return 0; } 12572c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12572f: 5b pop %ebx <== NOT EXECUTED 125730: 5e pop %esi <== NOT EXECUTED 125731: c9 leave <== NOT EXECUTED 125732: c3 ret <== NOT EXECUTED 125733: 90 nop <== NOT EXECUTED /* * 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 ); 125734: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 125737: 85 c0 test %eax,%eax <== NOT EXECUTED 125739: 74 10 je 12574b <== NOT EXECUTED 12573b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12573e: 85 c0 test %eax,%eax <== NOT EXECUTED 125740: 74 09 je 12574b <== NOT EXECUTED 125742: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125745: 56 push %esi <== NOT EXECUTED 125746: ff d0 call *%eax <== NOT EXECUTED 125748: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); 12574b: e8 04 c1 00 00 call 131854 <__errno> <== NOT EXECUTED 125750: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 125756: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED rtems_filesystem_freenode( fs_mount_loc ); free( mt_entry ); return 0; } 12575b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12575e: 5b pop %ebx <== NOT EXECUTED 12575f: 5e pop %esi <== NOT EXECUTED 125760: c9 leave <== NOT EXECUTED 125761: c3 ret <== NOT EXECUTED 125762: 66 90 xchg %ax,%ax <== NOT EXECUTED * 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){ 125764: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125767: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 12576a: 53 push %ebx <== NOT EXECUTED 12576b: ff 50 2c call *0x2c(%eax) <== NOT EXECUTED 12576e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125771: 85 c0 test %eax,%eax <== NOT EXECUTED 125773: 75 39 jne 1257ae <== NOT EXECUTED 125775: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125778: 53 push %ebx <== NOT EXECUTED 125779: e8 22 a6 fe ff call 10fda0 <_Chain_Extract> <== NOT EXECUTED /* * 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 ); 12577e: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 125781: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125784: 85 c0 test %eax,%eax <== NOT EXECUTED 125786: 74 13 je 12579b <== NOT EXECUTED 125788: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 12578b: 85 d2 test %edx,%edx <== NOT EXECUTED 12578d: 74 0c je 12579b <== NOT EXECUTED 12578f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125792: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 125795: 50 push %eax <== NOT EXECUTED 125796: ff d2 call *%edx <== NOT EXECUTED 125798: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free( mt_entry ); 12579b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12579e: 53 push %ebx <== NOT EXECUTED 12579f: e8 cc 5b fe ff call 10b370 <== NOT EXECUTED 1257a4: 31 c0 xor %eax,%eax <== NOT EXECUTED 1257a6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1257a9: e9 66 ff ff ff jmp 125714 <== NOT EXECUTED * 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 ) 1257ae: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1257b1: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 1257b4: 53 push %ebx <== NOT EXECUTED 1257b5: ff 50 20 call *0x20(%eax) <== NOT EXECUTED 1257b8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1257bb: 85 c0 test %eax,%eax <== NOT EXECUTED 1257bd: 0f 84 4c ff ff ff je 12570f <== NOT EXECUTED rtems_fatal_error_occurred( 0 ); 1257c3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1257c6: 6a 00 push $0x0 <== NOT EXECUTED 1257c8: e8 1b a2 fe ff call 10f9e8 <== NOT EXECUTED 1257cd: 8d 76 00 lea 0x0(%esi),%esi <== 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 ); 1257d0: e8 7f c0 00 00 call 131854 <__errno> <== NOT EXECUTED 1257d5: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1257db: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1257e0: e9 2f ff ff ff jmp 125714 <== NOT EXECUTED 0010e53c : int usleep( useconds_t useconds ) { 10e53c: 55 push %ebp <== NOT EXECUTED 10e53d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e53f: 57 push %edi <== NOT EXECUTED 10e540: 56 push %esi <== NOT EXECUTED 10e541: 53 push %ebx <== NOT EXECUTED 10e542: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 10e545: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED struct timespec tp; struct timespec tm; unsigned remaining; tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND; 10e548: ba 83 de 1b 43 mov $0x431bde83,%edx <== NOT EXECUTED 10e54d: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10e54f: f7 e2 mul %edx <== NOT EXECUTED 10e551: c1 ea 12 shr $0x12,%edx <== NOT EXECUTED 10e554: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000; 10e557: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e55a: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e55d: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e560: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e563: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e566: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e569: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 10e56c: 29 d1 sub %edx,%ecx <== NOT EXECUTED 10e56e: 8d 04 89 lea (%ecx,%ecx,4),%eax <== NOT EXECUTED 10e571: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10e574: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10e577: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 10e57a: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED nanosleep( &tp, &tm ); 10e57d: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10e580: 50 push %eax <== NOT EXECUTED 10e581: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10e584: 50 push %eax <== NOT EXECUTED 10e585: e8 1e 73 00 00 call 1158a8 <== NOT EXECUTED remaining = tm.tv_sec * TOD_MICROSECONDS_PER_SECOND; 10e58a: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10e58d: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e590: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e593: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e596: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e599: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e59c: 8d 3c 92 lea (%edx,%edx,4),%edi <== NOT EXECUTED 10e59f: c1 e7 06 shl $0x6,%edi <== NOT EXECUTED 10e5a2: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 10e5a5: b9 d3 4d 62 10 mov $0x10624dd3,%ecx <== NOT EXECUTED 10e5aa: 89 f0 mov %esi,%eax <== NOT EXECUTED 10e5ac: f7 e9 imul %ecx <== NOT EXECUTED 10e5ae: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e5b0: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 10e5b3: c1 fe 1f sar $0x1f,%esi <== NOT EXECUTED 10e5b6: 29 f0 sub %esi,%eax <== NOT EXECUTED 10e5b8: 01 f8 add %edi,%eax <== NOT EXECUTED remaining += tm.tv_nsec / 1000; return remaining; /* seconds remaining */ } 10e5ba: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e5bd: 5b pop %ebx <== NOT EXECUTED 10e5be: 5e pop %esi <== NOT EXECUTED 10e5bf: 5f pop %edi <== NOT EXECUTED 10e5c0: c9 leave <== NOT EXECUTED 10e5c1: c3 ret <== NOT EXECUTED 001257e8 : int utime( const char *path, const struct utimbuf *times ) { 1257e8: 55 push %ebp <== NOT EXECUTED 1257e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1257eb: 56 push %esi <== NOT EXECUTED 1257ec: 53 push %ebx <== NOT EXECUTED 1257ed: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1257f0: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED rtems_filesystem_location_info_t temp_loc; int result; if ( rtems_filesystem_evaluate_path( path, 0x00, &temp_loc, true ) ) 1257f3: 6a 01 push $0x1 <== NOT EXECUTED 1257f5: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 1257f8: 56 push %esi <== NOT EXECUTED 1257f9: 6a 00 push $0x0 <== NOT EXECUTED 1257fb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1257fe: e8 29 5a fe ff call 10b22c <== NOT EXECUTED 125803: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125806: 85 c0 test %eax,%eax <== NOT EXECUTED 125808: 75 56 jne 125860 <== NOT EXECUTED return -1; if ( !temp_loc.ops->utime_h ){ 12580a: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 12580d: 8b 50 30 mov 0x30(%eax),%edx <== NOT EXECUTED 125810: 85 d2 test %edx,%edx <== NOT EXECUTED 125812: 74 2e je 125842 <== 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 ); 125814: 50 push %eax <== NOT EXECUTED 125815: ff 73 04 pushl 0x4(%ebx) <== NOT EXECUTED 125818: ff 33 pushl (%ebx) <== NOT EXECUTED 12581a: 56 push %esi <== NOT EXECUTED 12581b: ff d2 call *%edx <== NOT EXECUTED 12581d: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &temp_loc ); 12581f: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 125822: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125825: 85 c0 test %eax,%eax <== NOT EXECUTED 125827: 74 10 je 125839 <== NOT EXECUTED 125829: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12582c: 85 c0 test %eax,%eax <== NOT EXECUTED 12582e: 74 09 je 125839 <== NOT EXECUTED 125830: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125833: 56 push %esi <== NOT EXECUTED 125834: ff d0 call *%eax <== NOT EXECUTED 125836: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 125839: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12583b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12583e: 5b pop %ebx <== NOT EXECUTED 12583f: 5e pop %esi <== NOT EXECUTED 125840: c9 leave <== NOT EXECUTED 125841: c3 ret <== NOT EXECUTED if ( rtems_filesystem_evaluate_path( path, 0x00, &temp_loc, true ) ) return -1; if ( !temp_loc.ops->utime_h ){ rtems_filesystem_freenode( &temp_loc ); 125842: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 125845: 85 c0 test %eax,%eax <== NOT EXECUTED 125847: 74 09 je 125852 <== NOT EXECUTED 125849: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12584c: 56 push %esi <== NOT EXECUTED 12584d: ff d0 call *%eax <== NOT EXECUTED 12584f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 125852: e8 fd bf 00 00 call 131854 <__errno> <== NOT EXECUTED 125857: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12585d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 125860: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime ); rtems_filesystem_freenode( &temp_loc ); return result; } 125865: 89 d8 mov %ebx,%eax <== NOT EXECUTED 125867: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12586a: 5b pop %ebx <== NOT EXECUTED 12586b: 5e pop %esi <== NOT EXECUTED 12586c: c9 leave <== NOT EXECUTED 12586d: c3 ret <== NOT EXECUTED 00107adc : */ void vprintk( const char *fmt, va_list ap ) { 107adc: 55 push %ebp <== NOT EXECUTED 107add: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107adf: 57 push %edi <== NOT EXECUTED 107ae0: 56 push %esi <== NOT EXECUTED 107ae1: 53 push %ebx <== NOT EXECUTED 107ae2: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 107ae5: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED char c, *str; int lflag, base, sign, width, lead, minus; for (; *fmt != '\0'; fmt++) { 107ae8: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 107aeb: 8a 02 mov (%edx),%al <== NOT EXECUTED 107aed: 84 c0 test %al,%al <== NOT EXECUTED 107aef: 0f 84 b9 00 00 00 je 107bae <== NOT EXECUTED base = 0; sign = 0; width = 0; minus = 0; lead = ' '; if (*fmt == '%') { 107af5: 3c 25 cmp $0x25,%al <== NOT EXECUTED 107af7: 0f 85 92 00 00 00 jne 107b8f <== NOT EXECUTED 107afd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED fmt++; 107b00: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 107b03: 41 inc %ecx <== NOT EXECUTED if (*fmt == '0' ) { 107b04: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 107b07: 8a 50 01 mov 0x1(%eax),%dl <== NOT EXECUTED 107b0a: 80 fa 30 cmp $0x30,%dl <== NOT EXECUTED 107b0d: 0f 84 91 02 00 00 je 107da4 <== NOT EXECUTED 107b13: c7 45 c4 20 00 00 00 movl $0x20,-0x3c(%ebp) <== NOT EXECUTED lead = '0'; fmt++; } if (*fmt == '-' ) { 107b1a: 80 fa 2d cmp $0x2d,%dl <== NOT EXECUTED 107b1d: 0f 84 59 02 00 00 je 107d7c <== NOT EXECUTED 107b23: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) <== NOT EXECUTED minus = 1; fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { 107b2a: 8d 42 d0 lea -0x30(%edx),%eax <== NOT EXECUTED 107b2d: 3c 09 cmp $0x9,%al <== NOT EXECUTED 107b2f: 0f 87 5c 02 00 00 ja 107d91 <== NOT EXECUTED 107b35: 31 db xor %ebx,%ebx <== NOT EXECUTED 107b37: 90 nop <== NOT EXECUTED width *= 10; width += (*fmt - '0'); 107b38: 8d 04 9b lea (%ebx,%ebx,4),%eax <== NOT EXECUTED 107b3b: 0f be d2 movsbl %dl,%edx <== NOT EXECUTED 107b3e: 8d 5c 42 d0 lea -0x30(%edx,%eax,2),%ebx <== NOT EXECUTED fmt++; 107b42: 41 inc %ecx <== NOT EXECUTED } if (*fmt == '-' ) { minus = 1; fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { 107b43: 8a 11 mov (%ecx),%dl <== NOT EXECUTED 107b45: 8d 42 d0 lea -0x30(%edx),%eax <== NOT EXECUTED 107b48: 3c 09 cmp $0x9,%al <== NOT EXECUTED 107b4a: 76 ec jbe 107b38 <== NOT EXECUTED 107b4c: 89 5d d0 mov %ebx,-0x30(%ebp) <== NOT EXECUTED 107b4f: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED width *= 10; width += (*fmt - '0'); fmt++; } if ((c = *fmt) == 'l') { 107b52: 80 fa 6c cmp $0x6c,%dl <== NOT EXECUTED 107b55: 0f 84 11 02 00 00 je 107d6c <== NOT EXECUTED lflag = 1; c = *++fmt; } switch (c) { 107b5b: 8d 42 bc lea -0x44(%edx),%eax <== NOT EXECUTED 107b5e: 3c 34 cmp $0x34,%al <== NOT EXECUTED 107b60: 76 56 jbe 107bb8 <== NOT EXECUTED break; case 'c': BSP_output_char(va_arg(ap, int)); break; default: BSP_output_char(c); 107b62: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107b65: 0f be c2 movsbl %dl,%eax <== NOT EXECUTED 107b68: 50 push %eax <== NOT EXECUTED 107b69: ff 15 64 b2 11 00 call *0x11b264 <== NOT EXECUTED 107b6f: 89 7d cc mov %edi,-0x34(%ebp) <== NOT EXECUTED 107b72: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107b75: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { char c, *str; int lflag, base, sign, width, lead, minus; for (; *fmt != '\0'; fmt++) { 107b78: ff 45 08 incl 0x8(%ebp) <== NOT EXECUTED 107b7b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 107b7e: 8a 02 mov (%edx),%al <== NOT EXECUTED 107b80: 84 c0 test %al,%al <== NOT EXECUTED 107b82: 74 2a je 107bae <== NOT EXECUTED 107b84: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED base = 0; sign = 0; width = 0; minus = 0; lead = ' '; if (*fmt == '%') { 107b87: 3c 25 cmp $0x25,%al <== NOT EXECUTED 107b89: 0f 84 71 ff ff ff je 107b00 <== NOT EXECUTED if (base) printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int), base, sign, width, lead); } else { BSP_output_char(*fmt); 107b8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107b92: 0f be c0 movsbl %al,%eax <== NOT EXECUTED 107b95: 50 push %eax <== NOT EXECUTED 107b96: ff 15 64 b2 11 00 call *0x11b264 <== NOT EXECUTED 107b9c: 89 7d cc mov %edi,-0x34(%ebp) <== NOT EXECUTED 107b9f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { char c, *str; int lflag, base, sign, width, lead, minus; for (; *fmt != '\0'; fmt++) { 107ba2: ff 45 08 incl 0x8(%ebp) <== NOT EXECUTED 107ba5: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 107ba8: 8a 02 mov (%edx),%al <== NOT EXECUTED 107baa: 84 c0 test %al,%al <== NOT EXECUTED 107bac: 75 d6 jne 107b84 <== NOT EXECUTED base, sign, width, lead); } else { BSP_output_char(*fmt); } } } 107bae: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107bb1: 5b pop %ebx <== NOT EXECUTED 107bb2: 5e pop %esi <== NOT EXECUTED 107bb3: 5f pop %edi <== NOT EXECUTED 107bb4: c9 leave <== NOT EXECUTED 107bb5: c3 ret <== NOT EXECUTED 107bb6: 66 90 xchg %ax,%ax <== NOT EXECUTED if ((c = *fmt) == 'l') { lflag = 1; c = *++fmt; } switch (c) { 107bb8: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 107bbb: ff 24 85 04 8f 11 00 jmp *0x118f04(,%eax,4) <== NOT EXECUTED break; case 'c': BSP_output_char(va_arg(ap, int)); break; default: BSP_output_char(c); 107bc2: 31 c0 xor %eax,%eax <== NOT EXECUTED 107bc4: be 08 00 00 00 mov $0x8,%esi <== NOT EXECUTED break; } /* switch*/ if (base) printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int), 107bc9: 8d 57 04 lea 0x4(%edi),%edx <== NOT EXECUTED 107bcc: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED 107bcf: 8b 1f mov (%edi),%ebx <== NOT EXECUTED { long unsigned int n; int count; char toPrint[20]; if ( (sign == 1) && ((long)num < 0) ) { 107bd1: 48 dec %eax <== NOT EXECUTED 107bd2: 0f 84 a4 00 00 00 je 107c7c <== NOT EXECUTED num = -num; if (maxwidth) maxwidth--; } count = 0; while ((n = num / base) > 0) { 107bd8: 89 d8 mov %ebx,%eax <== NOT EXECUTED 107bda: 31 d2 xor %edx,%edx <== NOT EXECUTED 107bdc: f7 f6 div %esi <== NOT EXECUTED 107bde: 85 c0 test %eax,%eax <== NOT EXECUTED 107be0: 0f 84 c4 00 00 00 je 107caa <== NOT EXECUTED 107be6: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 107be8: 89 c3 mov %eax,%ebx <== NOT EXECUTED 107bea: 31 ff xor %edi,%edi <== NOT EXECUTED 107bec: eb 06 jmp 107bf4 <== NOT EXECUTED 107bee: 66 90 xchg %ax,%ax <== NOT EXECUTED 107bf0: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 107bf2: 89 c3 mov %eax,%ebx <== NOT EXECUTED toPrint[count++] = (num - (n*base)); 107bf4: 89 d8 mov %ebx,%eax <== NOT EXECUTED 107bf6: 0f af c6 imul %esi,%eax <== NOT EXECUTED 107bf9: 28 c1 sub %al,%cl <== NOT EXECUTED 107bfb: 88 4c 3d e0 mov %cl,-0x20(%ebp,%edi,1) <== NOT EXECUTED 107bff: 47 inc %edi <== NOT EXECUTED num = -num; if (maxwidth) maxwidth--; } count = 0; while ((n = num / base) > 0) { 107c00: 89 d8 mov %ebx,%eax <== NOT EXECUTED 107c02: 31 d2 xor %edx,%edx <== NOT EXECUTED 107c04: f7 f6 div %esi <== NOT EXECUTED 107c06: 85 c0 test %eax,%eax <== NOT EXECUTED 107c08: 75 e6 jne 107bf0 <== NOT EXECUTED 107c0a: 8d 77 01 lea 0x1(%edi),%esi <== NOT EXECUTED toPrint[count++] = (num - (n*base)); num = n; } toPrint[count++] = num; 107c0d: 88 5c 3d e0 mov %bl,-0x20(%ebp,%edi,1) <== NOT EXECUTED for (n=maxwidth ; n > count; n-- ) 107c11: 8b 5d d0 mov -0x30(%ebp),%ebx <== NOT EXECUTED 107c14: 39 f3 cmp %esi,%ebx <== NOT EXECUTED 107c16: 76 16 jbe 107c2e <== NOT EXECUTED 107c18: 0f be 7d c4 movsbl -0x3c(%ebp),%edi <== NOT EXECUTED BSP_output_char(lead); 107c1c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107c1f: 57 push %edi <== NOT EXECUTED 107c20: ff 15 64 b2 11 00 call *0x11b264 <== NOT EXECUTED toPrint[count++] = (num - (n*base)); num = n; } toPrint[count++] = num; for (n=maxwidth ; n > count; n-- ) 107c26: 4b dec %ebx <== NOT EXECUTED 107c27: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107c2a: 39 f3 cmp %esi,%ebx <== NOT EXECUTED 107c2c: 77 ee ja 107c1c <== NOT EXECUTED BSP_output_char(lead); for (n = 0; n < count; n++) { 107c2e: 85 f6 test %esi,%esi <== NOT EXECUTED 107c30: 0f 84 42 ff ff ff je 107b78 <== NOT EXECUTED 107c36: 31 db xor %ebx,%ebx <== NOT EXECUTED 107c38: 8d 7c 35 f4 lea -0xc(%ebp,%esi,1),%edi <== NOT EXECUTED BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]); 107c3c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107c3f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 107c41: f7 d0 not %eax <== NOT EXECUTED 107c43: 0f be 44 38 ec movsbl -0x14(%eax,%edi,1),%eax <== NOT EXECUTED 107c48: 0f be 80 f2 8e 11 00 movsbl 0x118ef2(%eax),%eax <== NOT EXECUTED 107c4f: 50 push %eax <== NOT EXECUTED 107c50: ff 15 64 b2 11 00 call *0x11b264 <== NOT EXECUTED toPrint[count++] = num; for (n=maxwidth ; n > count; n-- ) BSP_output_char(lead); for (n = 0; n < count; n++) { 107c56: 43 inc %ebx <== NOT EXECUTED 107c57: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107c5a: 39 de cmp %ebx,%esi <== NOT EXECUTED 107c5c: 77 de ja 107c3c <== NOT EXECUTED 107c5e: e9 15 ff ff ff jmp 107b78 <== NOT EXECUTED if ((c = *fmt) == 'l') { lflag = 1; c = *++fmt; } switch (c) { 107c63: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 107c68: be 0a 00 00 00 mov $0xa,%esi <== NOT EXECUTED BSP_output_char(c); break; } /* switch*/ if (base) printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int), 107c6d: 8d 57 04 lea 0x4(%edi),%edx <== NOT EXECUTED 107c70: 89 55 cc mov %edx,-0x34(%ebp) <== NOT EXECUTED 107c73: 8b 1f mov (%edi),%ebx <== NOT EXECUTED { long unsigned int n; int count; char toPrint[20]; if ( (sign == 1) && ((long)num < 0) ) { 107c75: 48 dec %eax <== NOT EXECUTED 107c76: 0f 85 5c ff ff ff jne 107bd8 <== NOT EXECUTED 107c7c: 85 db test %ebx,%ebx <== NOT EXECUTED 107c7e: 0f 89 54 ff ff ff jns 107bd8 <== NOT EXECUTED BSP_output_char('-'); 107c84: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107c87: 6a 2d push $0x2d <== NOT EXECUTED 107c89: ff 15 64 b2 11 00 call *0x11b264 <== NOT EXECUTED num = -num; 107c8f: f7 db neg %ebx <== NOT EXECUTED if (maxwidth) maxwidth--; 107c91: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107c94: 83 7d d0 01 cmpl $0x1,-0x30(%ebp) <== NOT EXECUTED 107c98: 83 55 d0 ff adcl $0xffffffff,-0x30(%ebp) <== NOT EXECUTED } count = 0; while ((n = num / base) > 0) { 107c9c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 107c9e: 31 d2 xor %edx,%edx <== NOT EXECUTED 107ca0: f7 f6 div %esi <== NOT EXECUTED 107ca2: 85 c0 test %eax,%eax <== NOT EXECUTED 107ca4: 0f 85 3c ff ff ff jne 107be6 <== NOT EXECUTED 107caa: 31 ff xor %edi,%edi <== NOT EXECUTED 107cac: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 107cb1: e9 57 ff ff ff jmp 107c0d <== NOT EXECUTED case 'p': base = 16; sign = 0; break; case 's': { int i, len; char *s; str = va_arg(ap, char *); 107cb6: 8d 47 04 lea 0x4(%edi),%eax <== NOT EXECUTED 107cb9: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED 107cbc: 8b 3f mov (%edi),%edi <== NOT EXECUTED 107cbe: 89 7d c0 mov %edi,-0x40(%ebp) <== NOT EXECUTED /* calculate length of string */ for ( len=0, s=str ; *s ; len++, s++ ) 107cc1: 80 3f 00 cmpb $0x0,(%edi) <== NOT EXECUTED 107cc4: 0f 84 16 01 00 00 je 107de0 <== NOT EXECUTED 107cca: 31 ff xor %edi,%edi <== NOT EXECUTED 107ccc: 47 inc %edi <== NOT EXECUTED 107ccd: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED 107cd0: 80 3c 3a 00 cmpb $0x0,(%edx,%edi,1) <== NOT EXECUTED 107cd4: 75 f6 jne 107ccc <== NOT EXECUTED ; /* leading spaces */ if ( !minus ) 107cd6: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 107cd9: 85 c9 test %ecx,%ecx <== NOT EXECUTED 107cdb: 0f 84 db 00 00 00 je 107dbc <== NOT EXECUTED for ( i=len ; i <== NOT EXECUTED 107ce5: 89 7d d0 mov %edi,-0x30(%ebp) <== NOT EXECUTED width = len; } /* output the string */ for ( i=0 ; i <== NOT EXECUTED 107cef: 8b 55 c0 mov -0x40(%ebp),%edx <== NOT EXECUTED 107cf2: 8a 02 mov (%edx),%al <== NOT EXECUTED 107cf4: 84 c0 test %al,%al <== NOT EXECUTED 107cf6: 74 1c je 107d14 <== NOT EXECUTED BSP_output_char(*str); 107cf8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107cfb: 0f be c0 movsbl %al,%eax <== NOT EXECUTED 107cfe: 50 push %eax <== NOT EXECUTED 107cff: ff 15 64 b2 11 00 call *0x11b264 <== NOT EXECUTED if (width == 0) { width = len; } /* output the string */ for ( i=0 ; i <== NOT EXECUTED BSP_output_char(*str); /* trailing spaces */ if ( minus ) 107d14: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 107d17: 85 c0 test %eax,%eax <== NOT EXECUTED 107d19: 0f 84 59 fe ff ff je 107b78 <== NOT EXECUTED for ( i=len ; i <== NOT EXECUTED 107d28: 89 fb mov %edi,%ebx <== NOT EXECUTED 107d2a: 66 90 xchg %ax,%ax <== NOT EXECUTED BSP_output_char(' '); 107d2c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107d2f: 6a 20 push $0x20 <== NOT EXECUTED 107d31: ff 15 64 b2 11 00 call *0x11b264 <== NOT EXECUTED for ( i=0 ; i <== NOT EXECUTED 107d40: e9 33 fe ff ff jmp 107b78 <== NOT EXECUTED BSP_output_char(' '); } break; case 'c': BSP_output_char(va_arg(ap, int)); 107d45: 8d 47 04 lea 0x4(%edi),%eax <== NOT EXECUTED 107d48: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED 107d4b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107d4e: 0f be 07 movsbl (%edi),%eax <== NOT EXECUTED 107d51: 50 push %eax <== NOT EXECUTED 107d52: ff 15 64 b2 11 00 call *0x11b264 <== NOT EXECUTED 107d58: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107d5b: e9 18 fe ff ff jmp 107b78 <== NOT EXECUTED if ((c = *fmt) == 'l') { lflag = 1; c = *++fmt; } switch (c) { 107d60: 31 c0 xor %eax,%eax <== NOT EXECUTED 107d62: be 0a 00 00 00 mov $0xa,%esi <== NOT EXECUTED 107d67: e9 5d fe ff ff jmp 107bc9 <== NOT EXECUTED fmt++; } if ((c = *fmt) == 'l') { lflag = 1; c = *++fmt; 107d6c: 8d 51 01 lea 0x1(%ecx),%edx <== NOT EXECUTED 107d6f: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED 107d72: 8a 51 01 mov 0x1(%ecx),%dl <== NOT EXECUTED 107d75: e9 e1 fd ff ff jmp 107b5b <== NOT EXECUTED 107d7a: 66 90 xchg %ax,%ax <== NOT EXECUTED lead = '0'; fmt++; } if (*fmt == '-' ) { minus = 1; fmt++; 107d7c: 41 inc %ecx <== NOT EXECUTED 107d7d: 8a 11 mov (%ecx),%dl <== NOT EXECUTED 107d7f: c7 45 c8 01 00 00 00 movl $0x1,-0x38(%ebp) <== NOT EXECUTED } while (*fmt >= '0' && *fmt <= '9' ) { 107d86: 8d 42 d0 lea -0x30(%edx),%eax <== NOT EXECUTED 107d89: 3c 09 cmp $0x9,%al <== NOT EXECUTED 107d8b: 0f 86 a4 fd ff ff jbe 107b35 <== NOT EXECUTED 107d91: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED 107d94: 31 db xor %ebx,%ebx <== NOT EXECUTED 107d96: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) <== NOT EXECUTED 107d9d: e9 b0 fd ff ff jmp 107b52 <== NOT EXECUTED 107da2: 66 90 xchg %ax,%ax <== NOT EXECUTED lead = ' '; if (*fmt == '%') { fmt++; if (*fmt == '0' ) { lead = '0'; fmt++; 107da4: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 107da7: 83 c1 02 add $0x2,%ecx <== NOT EXECUTED 107daa: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 107dad: 8a 50 02 mov 0x2(%eax),%dl <== NOT EXECUTED 107db0: c7 45 c4 30 00 00 00 movl $0x30,-0x3c(%ebp) <== NOT EXECUTED 107db7: e9 5e fd ff ff jmp 107b1a <== NOT EXECUTED for ( len=0, s=str ; *s ; len++, s++ ) ; /* leading spaces */ if ( !minus ) for ( i=len ; i <== NOT EXECUTED 107dc4: 89 fe mov %edi,%esi <== NOT EXECUTED 107dc6: 66 90 xchg %ax,%ax <== NOT EXECUTED BSP_output_char(' '); 107dc8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107dcb: 6a 20 push $0x20 <== NOT EXECUTED 107dcd: ff 15 64 b2 11 00 call *0x11b264 <== NOT EXECUTED for ( len=0, s=str ; *s ; len++, s++ ) ; /* leading spaces */ if ( !minus ) for ( i=len ; i <== NOT EXECUTED 107ddb: e9 08 ff ff ff jmp 107ce8 <== NOT EXECUTED char *s; str = va_arg(ap, char *); /* calculate length of string */ for ( len=0, s=str ; *s ; len++, s++ ) 107de0: 31 ff xor %edi,%edi <== NOT EXECUTED 107de2: e9 ef fe ff ff jmp 107cd6 <== NOT EXECUTED break; case 'c': BSP_output_char(va_arg(ap, int)); break; default: BSP_output_char(c); 107de7: 31 c0 xor %eax,%eax <== NOT EXECUTED 107de9: be 10 00 00 00 mov $0x10,%esi <== NOT EXECUTED 107dee: e9 d6 fd ff ff jmp 107bc9 <== NOT EXECUTED 0010a4ac : #include int wait( int *stat_loc ) { 10a4ac: 55 push %ebp <== NOT EXECUTED 10a4ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4af: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a4b2: e8 c9 75 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a4b7: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a4bd: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a4c2: c9 leave <== NOT EXECUTED 10a4c3: c3 ret <== NOT EXECUTED 0010a4c4 : int waitpid( pid_t pid, int *stat_loc, int options ) { 10a4c4: 55 push %ebp <== NOT EXECUTED 10a4c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a4c7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSYS ); 10a4ca: e8 b1 75 00 00 call 111a80 <__errno> <== NOT EXECUTED 10a4cf: c7 00 58 00 00 00 movl $0x58,(%eax) <== NOT EXECUTED } 10a4d5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10a4da: c9 leave <== NOT EXECUTED 10a4db: c3 ret <== NOT EXECUTED 00117404 : ssize_t write( int fd, const void *buffer, size_t count ) { 117404: 55 push %ebp <== NOT EXECUTED 117405: 89 e5 mov %esp,%ebp <== NOT EXECUTED 117407: 56 push %esi <== NOT EXECUTED 117408: 53 push %ebx <== NOT EXECUTED 117409: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 11740c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11740f: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 117412: 3b 15 00 b1 11 00 cmp 0x11b100,%edx <== NOT EXECUTED 117418: 73 56 jae 117470 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 11741a: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 11741d: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 117420: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 117427: 03 1d 30 f6 11 00 add 0x11f630,%ebx <== NOT EXECUTED rtems_libio_check_is_open( iop ); 11742d: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 117430: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 117433: 74 3b je 117470 <== NOT EXECUTED rtems_libio_check_buffer( buffer ); 117435: 85 f6 test %esi,%esi <== NOT EXECUTED 117437: 74 4b je 117484 <== NOT EXECUTED rtems_libio_check_count( count ); 117439: 85 c9 test %ecx,%ecx <== NOT EXECUTED 11743b: 74 27 je 117464 <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 11743d: a8 04 test $0x4,%al <== NOT EXECUTED 11743f: 74 43 je 117484 <== NOT EXECUTED /* * Now process the write() request. */ if ( !iop->handlers->write_h ) 117441: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 117444: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 117447: 85 c0 test %eax,%eax <== NOT EXECUTED 117449: 74 4b je 117496 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); rc = (*iop->handlers->write_h)( iop, buffer, count ); 11744b: 52 push %edx <== NOT EXECUTED 11744c: 51 push %ecx <== NOT EXECUTED 11744d: 56 push %esi <== NOT EXECUTED 11744e: 53 push %ebx <== NOT EXECUTED 11744f: ff d0 call *%eax <== NOT EXECUTED if ( rc > 0 ) 117451: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 117454: 85 c0 test %eax,%eax <== NOT EXECUTED 117456: 7e 03 jle 11745b <== NOT EXECUTED iop->offset += rc; 117458: 01 43 08 add %eax,0x8(%ebx) <== NOT EXECUTED return rc; } 11745b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11745e: 5b pop %ebx <== NOT EXECUTED 11745f: 5e pop %esi <== NOT EXECUTED 117460: c9 leave <== NOT EXECUTED 117461: c3 ret <== NOT EXECUTED 117462: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); 117464: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( rc > 0 ) iop->offset += rc; return rc; } 117466: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 117469: 5b pop %ebx <== NOT EXECUTED 11746a: 5e pop %esi <== NOT EXECUTED 11746b: c9 leave <== NOT EXECUTED 11746c: c3 ret <== NOT EXECUTED 11746d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); 117470: e8 0b 98 ff ff call 110c80 <__errno> <== NOT EXECUTED 117475: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 11747b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 117480: eb d9 jmp 11745b <== NOT EXECUTED 117482: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 117484: e8 f7 97 ff ff call 110c80 <__errno> <== NOT EXECUTED 117489: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11748f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 117494: eb c5 jmp 11745b <== NOT EXECUTED /* * Now process the write() request. */ if ( !iop->handlers->write_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 117496: e8 e5 97 ff ff call 110c80 <__errno> <== NOT EXECUTED 11749b: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1174a1: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1174a6: eb b3 jmp 11745b <== NOT EXECUTED