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 0010d800 : #define MAXSYMLINK 5 int IMFS_Set_handlers( rtems_filesystem_location_info_t *loc ) { 10d800: 55 push %ebp <== NOT EXECUTED 10d801: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d803: 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; 10d806: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10d809: 8b 48 2c mov 0x2c(%eax),%ecx <== NOT EXECUTED switch( node->type ) { 10d80c: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10d80e: 83 78 4c 06 cmpl $0x6,0x4c(%eax) <== NOT EXECUTED 10d812: 77 12 ja 10d826 <== NOT EXECUTED 10d814: 8b 40 4c mov 0x4c(%eax),%eax <== NOT EXECUTED 10d817: ff 24 85 80 88 11 00 jmp *0x118880(,%eax,4) <== NOT EXECUTED 10d81e: 66 90 xchg %ax,%ax <== NOT EXECUTED case IMFS_DIRECTORY: loc->handlers = fs_info->directory_handlers; 10d820: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10d823: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED loc->handlers = fs_info->memfile_handlers; break; } return 0; } 10d826: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d828: c9 leave <== NOT EXECUTED 10d829: c3 ret <== NOT EXECUTED 10d82a: 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; 10d82c: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d82f: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED break; } return 0; } 10d832: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d834: c9 leave <== NOT EXECUTED 10d835: c3 ret <== NOT EXECUTED 10d836: 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; 10d838: c7 42 04 60 89 11 00 movl $0x118960,0x4(%edx) <== NOT EXECUTED loc->handlers = fs_info->memfile_handlers; break; } return 0; } 10d83f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d841: c9 leave <== NOT EXECUTED 10d842: c3 ret <== NOT EXECUTED 10d843: 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; 10d844: c7 42 04 20 89 11 00 movl $0x118920,0x4(%edx) <== NOT EXECUTED loc->handlers = fs_info->memfile_handlers; break; } return 0; } 10d84b: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d84d: c9 leave <== NOT EXECUTED 10d84e: c3 ret <== NOT EXECUTED 001225d0 : int IMFS_chown( rtems_filesystem_location_info_t *pathloc, /* IN */ uid_t owner, /* IN */ gid_t group /* IN */ ) { 1225d0: 55 push %ebp <== NOT EXECUTED 1225d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1225d3: 53 push %ebx <== NOT EXECUTED 1225d4: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED IMFS_jnode_t *jnode; #if defined(RTEMS_POSIX_API) uid_t st_uid; #endif jnode = (IMFS_jnode_t *) pathloc->node_access; 1225d7: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1225da: 8b 18 mov (%eax),%ebx <== NOT EXECUTED if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) ) rtems_set_errno_and_return_minus_one( EPERM ); #endif jnode->st_uid = owner; 1225dc: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1225df: 66 89 43 3c mov %ax,0x3c(%ebx) <== NOT EXECUTED jnode->st_gid = group; 1225e3: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1225e6: 66 89 43 3e mov %ax,0x3e(%ebx) <== NOT EXECUTED IMFS_update_ctime( jnode ); 1225ea: 6a 00 push $0x0 <== NOT EXECUTED 1225ec: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1225ef: 50 push %eax <== NOT EXECUTED 1225f0: e8 f7 8d fe ff call 10b3ec <== NOT EXECUTED 1225f5: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 1225f8: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED return 0; } 1225fb: 31 c0 xor %eax,%eax <== NOT EXECUTED 1225fd: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 122600: c9 leave <== NOT EXECUTED 122601: c3 ret <== NOT EXECUTED 0010fa5c : IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) { 10fa5c: 55 push %ebp <== NOT EXECUTED 10fa5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fa5f: 57 push %edi <== NOT EXECUTED 10fa60: 56 push %esi <== NOT EXECUTED 10fa61: 53 push %ebx <== NOT EXECUTED 10fa62: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10fa65: 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 ) 10fa68: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10fa6b: 85 db test %ebx,%ebx <== NOT EXECUTED 10fa6d: 0f 84 29 01 00 00 je 10fb9c <== NOT EXECUTED parent = parent_loc->node_access; 10fa73: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fa76: 8b 38 mov (%eax),%edi <== NOT EXECUTED /* * Allocate an IMFS jnode */ node = calloc( 1, sizeof( IMFS_jnode_t ) ); 10fa78: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10fa7b: 6a 60 push $0x60 <== NOT EXECUTED 10fa7d: 6a 01 push $0x1 <== NOT EXECUTED 10fa7f: e8 d0 e9 ff ff call 10e454 <== NOT EXECUTED 10fa84: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !node ) 10fa86: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fa89: 85 c0 test %eax,%eax <== NOT EXECUTED 10fa8b: 0f 84 9f 00 00 00 je 10fb30 <== NOT EXECUTED /* * Fill in the basic information */ node->st_nlink = 1; 10fa91: 66 c7 40 34 01 00 movw $0x1,0x34(%eax) <== NOT EXECUTED node->type = type; 10fa97: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10fa9a: 89 50 4c mov %edx,0x4c(%eax) <== NOT EXECUTED strncpy( node->name, name, IMFS_NAME_MAX ); 10fa9d: 51 push %ecx <== NOT EXECUTED 10fa9e: 6a 20 push $0x20 <== NOT EXECUTED 10faa0: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10faa3: 8d 40 0c lea 0xc(%eax),%eax <== NOT EXECUTED 10faa6: 50 push %eax <== NOT EXECUTED 10faa7: e8 94 18 00 00 call 111340 <== NOT EXECUTED /* * Fill in the mode and permission information for the jnode structure. */ node->st_mode = mode & ~rtems_filesystem_umask; 10faac: a1 54 c8 11 00 mov 0x11c854,%eax <== NOT EXECUTED 10fab1: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED 10fab4: f7 d0 not %eax <== NOT EXECUTED 10fab6: 21 c6 and %eax,%esi <== NOT EXECUTED 10fab8: 89 73 30 mov %esi,0x30(%ebx) <== NOT EXECUTED #if defined(RTEMS_POSIX_API) node->st_uid = geteuid(); node->st_gid = getegid(); #else node->st_uid = 0; 10fabb: 66 c7 43 3c 00 00 movw $0x0,0x3c(%ebx) <== NOT EXECUTED node->st_gid = 0; 10fac1: 66 c7 43 3e 00 00 movw $0x0,0x3e(%ebx) <== NOT EXECUTED /* * Now set all the times. */ gettimeofday( &tv, 0 ); 10fac7: 58 pop %eax <== NOT EXECUTED 10fac8: 5a pop %edx <== NOT EXECUTED 10fac9: 6a 00 push $0x0 <== NOT EXECUTED 10facb: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10face: 50 push %eax <== NOT EXECUTED 10facf: e8 18 eb ff ff call 10e5ec <== NOT EXECUTED node->stat_atime = (time_t) tv.tv_sec; 10fad4: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10fad7: 89 43 40 mov %eax,0x40(%ebx) <== NOT EXECUTED node->stat_mtime = (time_t) tv.tv_sec; 10fada: 89 43 44 mov %eax,0x44(%ebx) <== NOT EXECUTED node->stat_ctime = (time_t) tv.tv_sec; 10fadd: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED /* * Set the type specific information */ switch (type) { 10fae0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fae3: 83 7d 0c 06 cmpl $0x6,0xc(%ebp) <== NOT EXECUTED 10fae7: 76 53 jbe 10fb3c <== NOT EXECUTED node->info.file.doubly_indirect = 0; node->info.file.triply_indirect = 0; break; default: assert(0); 10fae9: 68 08 82 11 00 push $0x118208 <== NOT EXECUTED 10faee: 68 f8 8b 11 00 push $0x118bf8 <== NOT EXECUTED 10faf3: 6a 74 push $0x74 <== NOT EXECUTED 10faf5: 68 90 8b 11 00 push $0x118b90 <== NOT EXECUTED 10fafa: e8 69 73 ff ff call 106e68 <__assert_func> <== NOT EXECUTED 10faff: 90 nop <== 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; 10fb00: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 10fb03: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10fb05: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED /* * If this node has a parent, then put it in that directory list. */ if ( parent ) { 10fb08: 85 ff test %edi,%edi <== NOT EXECUTED 10fb0a: 74 24 je 10fb30 <== NOT EXECUTED 10fb0c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10fb0f: 53 push %ebx <== NOT EXECUTED 10fb10: 8d 47 50 lea 0x50(%edi),%eax <== NOT EXECUTED 10fb13: 50 push %eax <== NOT EXECUTED 10fb14: e8 1f b2 ff ff call 10ad38 <_Chain_Append> <== NOT EXECUTED rtems_chain_append( &parent->info.directory.Entries, &node->Node ); node->Parent = parent; 10fb19: 89 7b 08 mov %edi,0x8(%ebx) <== NOT EXECUTED fs_info = parent_loc->mt_entry->fs_info; 10fb1c: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10fb1f: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10fb22: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED node->st_ino = ++fs_info->ino_count; 10fb25: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10fb27: 40 inc %eax <== NOT EXECUTED 10fb28: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10fb2a: 89 43 38 mov %eax,0x38(%ebx) <== NOT EXECUTED 10fb2d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return node; } 10fb30: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10fb32: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fb35: 5b pop %ebx <== NOT EXECUTED 10fb36: 5e pop %esi <== NOT EXECUTED 10fb37: 5f pop %edi <== NOT EXECUTED 10fb38: c9 leave <== NOT EXECUTED 10fb39: c3 ret <== NOT EXECUTED 10fb3a: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Set the type specific information */ switch (type) { 10fb3c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10fb3f: ff 24 85 dc 8b 11 00 jmp *0x118bdc(,%eax,4) <== NOT EXECUTED 10fb46: 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; 10fb48: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED node->info.linearfile.direct = 0; 10fb4f: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED case IMFS_MEMORY_FILE: node->info.file.size = 0; 10fb56: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED node->info.file.indirect = 0; 10fb5d: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED node->info.file.doubly_indirect = 0; 10fb64: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED node->info.file.triply_indirect = 0; 10fb6b: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED 10fb72: eb 94 jmp 10fb08 <== 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; 10fb74: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 10fb77: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10fb79: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED node->info.device.minor = info->device.minor; 10fb7c: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10fb7f: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED 10fb82: eb 84 jmp 10fb08 <== NOT EXECUTED 10fb84: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10fb87: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED 10fb8a: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED 10fb91: 8d 43 50 lea 0x50(%ebx),%eax <== NOT EXECUTED 10fb94: 89 43 58 mov %eax,0x58(%ebx) <== NOT EXECUTED 10fb97: e9 6c ff ff ff jmp 10fb08 <== NOT EXECUTED IMFS_jnode_t *node; struct timeval tv; IMFS_jnode_t *parent = NULL; IMFS_fs_info_t *fs_info; if ( parent_loc != NULL ) 10fb9c: 31 ff xor %edi,%edi <== NOT EXECUTED 10fb9e: e9 d5 fe ff ff jmp 10fa78 <== NOT EXECUTED 0010d988 : int IMFS_eval_path( const char *pathname, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10d988: 55 push %ebp <== NOT EXECUTED 10d989: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d98b: 57 push %edi <== NOT EXECUTED 10d98c: 56 push %esi <== NOT EXECUTED 10d98d: 53 push %ebx <== NOT EXECUTED 10d98e: 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; 10d991: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10d994: 8b 18 mov (%eax),%ebx <== NOT EXECUTED 10d996: 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 ); 10d99d: 50 push %eax <== NOT EXECUTED 10d99e: 8d 55 f0 lea -0x10(%ebp),%edx <== NOT EXECUTED 10d9a1: 52 push %edx <== NOT EXECUTED 10d9a2: 8d 4d bf lea -0x41(%ebp),%ecx <== NOT EXECUTED 10d9a5: 51 push %ecx <== NOT EXECUTED 10d9a6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d9a9: 03 45 a4 add -0x5c(%ebp),%eax <== NOT EXECUTED 10d9ac: 50 push %eax <== NOT EXECUTED 10d9ad: e8 1a 06 00 00 call 10dfcc <== NOT EXECUTED i += len; 10d9b2: 8b 75 f0 mov -0x10(%ebp),%esi <== NOT EXECUTED 10d9b5: 89 75 a0 mov %esi,-0x60(%ebp) <== NOT EXECUTED if ( !pathloc->node_access ) 10d9b8: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10d9bb: 8b 17 mov (%edi),%edx <== NOT EXECUTED 10d9bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d9c0: 85 d2 test %edx,%edx <== NOT EXECUTED 10d9c2: 0f 84 98 01 00 00 je 10db60 <== NOT EXECUTED */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], token, &len ); i += len; 10d9c8: 8b 4d a0 mov -0x60(%ebp),%ecx <== NOT EXECUTED 10d9cb: 01 4d a4 add %ecx,-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 ) 10d9ce: 85 c0 test %eax,%eax <== NOT EXECUTED 10d9d0: 75 56 jne 10da28 <== 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 ) { 10d9d2: 83 7a 4c 01 cmpl $0x1,0x4c(%edx) <== NOT EXECUTED 10d9d6: 0f 85 3c 01 00 00 jne 10db18 <== NOT EXECUTED if ( node->info.directory.mt_fs != NULL ) { 10d9dc: 8b 42 5c mov 0x5c(%edx),%eax <== NOT EXECUTED 10d9df: 85 c0 test %eax,%eax <== NOT EXECUTED 10d9e1: 0f 84 31 01 00 00 je 10db18 <== NOT EXECUTED newloc = node->info.directory.mt_fs->mt_fs_root; 10d9e7: 8d 55 e0 lea -0x20(%ebp),%edx <== NOT EXECUTED 10d9ea: 83 c0 18 add $0x18,%eax <== NOT EXECUTED 10d9ed: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10d9f2: 89 d7 mov %edx,%edi <== NOT EXECUTED 10d9f4: 89 c6 mov %eax,%esi <== NOT EXECUTED 10d9f6: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10d9f8: b1 04 mov $0x4,%cl <== NOT EXECUTED 10d9fa: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10d9fd: 89 d6 mov %edx,%esi <== NOT EXECUTED 10d9ff: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc ); 10da01: 57 push %edi <== NOT EXECUTED 10da02: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10da05: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10da08: 50 push %eax <== NOT EXECUTED 10da09: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10da0c: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10da0f: 29 4d a4 sub %ecx,-0x5c(%ebp) <== NOT EXECUTED 10da12: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10da15: 03 45 a4 add -0x5c(%ebp),%eax <== NOT EXECUTED 10da18: 50 push %eax <== NOT EXECUTED 10da19: ff 12 call *(%edx) <== NOT EXECUTED 10da1b: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10da1d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10da20: e9 bf 00 00 00 jmp 10dae4 <== NOT EXECUTED 10da25: 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 ) 10da28: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) <== NOT EXECUTED 10da2c: 0f 84 be 00 00 00 je 10daf0 <== NOT EXECUTED 10da32: 89 d3 mov %edx,%ebx <== 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 ) { 10da34: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10da37: 74 1b je 10da54 <== NOT EXECUTED 10da39: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10da3c: 0f 84 92 00 00 00 je 10dad4 <== NOT EXECUTED 10da42: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10da45: 74 59 je 10daa0 <== NOT EXECUTED /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10da47: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10da4a: 0f 85 4d ff ff ff jne 10d99d <== NOT EXECUTED 10da50: eb 80 jmp 10d9d2 <== NOT EXECUTED 10da52: 66 90 xchg %ax,%ax <== NOT EXECUTED case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 10da54: 8b 42 4c mov 0x4c(%edx),%eax <== NOT EXECUTED 10da57: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10da5a: 0f 84 dc 00 00 00 je 10db3c <== NOT EXECUTED node = pathloc->node_access; if ( !node ) rtems_set_errno_and_return_minus_one( ENOTDIR ); } else if ( node->type == IMFS_SYM_LINK ) { 10da60: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10da63: 0f 84 21 01 00 00 je 10db8a <== NOT EXECUTED /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10da69: 48 dec %eax <== NOT EXECUTED 10da6a: 0f 85 05 01 00 00 jne 10db75 <== 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 ) { 10da70: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED 10da73: 85 c0 test %eax,%eax <== NOT EXECUTED 10da75: 0f 85 6c ff ff ff jne 10d9e7 <== NOT EXECUTED /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10da7b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10da7e: 8d 75 bf lea -0x41(%ebp),%esi <== NOT EXECUTED 10da81: 56 push %esi <== NOT EXECUTED 10da82: 53 push %ebx <== NOT EXECUTED 10da83: e8 a0 04 00 00 call 10df28 <== NOT EXECUTED 10da88: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !node ) 10da8a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10da8d: 85 c0 test %eax,%eax <== NOT EXECUTED 10da8f: 0f 84 cb 00 00 00 je 10db60 <== NOT EXECUTED /* * Set the node access to the point we have found. */ pathloc->node_access = node; 10da95: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10da98: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10da9a: e9 fe fe ff ff jmp 10d99d <== NOT EXECUTED 10da9f: 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 ) 10daa0: a1 54 c8 11 00 mov 0x11c854,%eax <== NOT EXECUTED 10daa5: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10daa8: 0f 84 ef fe ff ff je 10d99d <== NOT EXECUTED /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 10daae: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10dab1: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10dab4: 3b 50 18 cmp 0x18(%eax),%edx <== NOT EXECUTED 10dab7: 0f 84 f3 00 00 00 je 10dbb0 <== NOT EXECUTED *pathloc = newloc; return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc); } } else { if ( !node->Parent ) 10dabd: 8b 5a 08 mov 0x8(%edx),%ebx <== NOT EXECUTED 10dac0: 85 db test %ebx,%ebx <== NOT EXECUTED 10dac2: 0f 84 98 00 00 00 je 10db60 <== NOT EXECUTED node = node->Parent; pathloc->node_access = node; } pathloc->node_access = node; 10dac8: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10dacb: 89 1e mov %ebx,(%esi) <== NOT EXECUTED 10dacd: e9 cb fe ff ff jmp 10d99d <== NOT EXECUTED 10dad2: 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 ); 10dad4: e8 df 26 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10dad9: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED 10dadf: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10dae4: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10dae6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dae9: 5b pop %ebx <== NOT EXECUTED 10daea: 5e pop %esi <== NOT EXECUTED 10daeb: 5f pop %edi <== NOT EXECUTED 10daec: c9 leave <== NOT EXECUTED 10daed: c3 ret <== NOT EXECUTED 10daee: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !rtems_libio_is_valid_perms( flags ) ) { assert( 0 ); rtems_set_errno_and_return_minus_one( EIO ); } jnode = node->node_access; 10daf0: 89 d3 mov %edx,%ebx <== 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 ) 10daf2: f6 42 30 40 testb $0x40,0x30(%edx) <== NOT EXECUTED 10daf6: 0f 85 38 ff ff ff jne 10da34 <== NOT EXECUTED /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); 10dafc: e8 b7 26 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10db01: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10db07: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED return result; } 10db0c: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10db0e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10db11: 5b pop %ebx <== NOT EXECUTED 10db12: 5e pop %esi <== NOT EXECUTED 10db13: 5f pop %edi <== NOT EXECUTED 10db14: c9 leave <== NOT EXECUTED 10db15: c3 ret <== NOT EXECUTED 10db16: 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 ); 10db18: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10db1b: e8 e0 fc ff ff call 10d800 <== NOT EXECUTED 10db20: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10db22: 5e pop %esi <== 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 ) 10db23: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10db26: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 10db29: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10db2c: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10db2e: 8b 52 30 mov 0x30(%edx),%edx <== NOT EXECUTED 10db31: 21 c2 and %eax,%edx <== NOT EXECUTED 10db33: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10db35: 75 c5 jne 10dafc <== NOT EXECUTED 10db37: eb ab jmp 10dae4 <== NOT EXECUTED 10db39: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { IMFS_evaluate_hard_link( pathloc, 0 ); 10db3c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10db3f: 6a 00 push $0x0 <== NOT EXECUTED 10db41: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10db44: e8 27 fd ff ff call 10d870 <== NOT EXECUTED node = pathloc->node_access; 10db49: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10db4c: 8b 1f mov (%edi),%ebx <== NOT EXECUTED if ( !node ) 10db4e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10db51: 85 db test %ebx,%ebx <== NOT EXECUTED 10db53: 74 20 je 10db75 <== NOT EXECUTED } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_sym_link( pathloc, 0 ); node = pathloc->node_access; 10db55: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10db58: e9 0c ff ff ff jmp 10da69 <== NOT EXECUTED 10db5d: 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 ); 10db60: e8 53 26 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10db65: c7 00 02 00 00 00 movl $0x2,(%eax) <== NOT EXECUTED 10db6b: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 10db70: e9 6f ff ff ff jmp 10dae4 <== NOT EXECUTED /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 10db75: e8 3e 26 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10db7a: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 10db80: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 10db85: e9 5a ff ff ff jmp 10dae4 <== 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 ); 10db8a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10db8d: 6a 00 push $0x0 <== NOT EXECUTED 10db8f: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10db92: e8 31 fd ff ff call 10d8c8 <== NOT EXECUTED 10db97: 89 c1 mov %eax,%ecx <== NOT EXECUTED node = pathloc->node_access; 10db99: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10db9c: 8b 02 mov (%edx),%eax <== NOT EXECUTED if ( result == -1 ) 10db9e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dba1: 83 f9 ff cmp $0xffffffff,%ecx <== NOT EXECUTED 10dba4: 0f 84 3a ff ff ff je 10dae4 <== NOT EXECUTED } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_sym_link( pathloc, 0 ); node = pathloc->node_access; 10dbaa: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10dbac: eb a7 jmp 10db55 <== NOT EXECUTED 10dbae: 66 90 xchg %ax,%ax <== 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; 10dbb0: 8d 5d e0 lea -0x20(%ebp),%ebx <== NOT EXECUTED 10dbb3: 8d 50 08 lea 0x8(%eax),%edx <== NOT EXECUTED 10dbb6: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10dbbb: 89 df mov %ebx,%edi <== NOT EXECUTED 10dbbd: 89 d6 mov %edx,%esi <== NOT EXECUTED 10dbbf: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10dbc1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10dbc3: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10dbc6: 89 de mov %ebx,%esi <== NOT EXECUTED 10dbc8: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10dbca: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc); 10dbcc: 50 push %eax <== NOT EXECUTED 10dbcd: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10dbd0: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10dbd3: 50 push %eax <== NOT EXECUTED 10dbd4: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dbd7: 8b 4d a0 mov -0x60(%ebp),%ecx <== NOT EXECUTED 10dbda: e9 30 fe ff ff jmp 10da0f <== NOT EXECUTED 0010dc8c : int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { 10dc8c: 55 push %ebp <== NOT EXECUTED 10dc8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc8f: 57 push %edi <== NOT EXECUTED 10dc90: 56 push %esi <== NOT EXECUTED 10dc91: 53 push %ebx <== NOT EXECUTED 10dc92: 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; 10dc95: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10dc98: 8b 18 mov (%eax),%ebx <== NOT EXECUTED 10dc9a: c7 45 a8 00 00 00 00 movl $0x0,-0x58(%ebp) <== NOT EXECUTED * Evaluate all tokens until we are done or an error occurs. */ while( !done ) { type = IMFS_get_token( &path[i], token, &len ); 10dca1: 57 push %edi <== NOT EXECUTED 10dca2: 8d 55 f0 lea -0x10(%ebp),%edx <== NOT EXECUTED 10dca5: 52 push %edx <== NOT EXECUTED 10dca6: 8d 4d bf lea -0x41(%ebp),%ecx <== NOT EXECUTED 10dca9: 51 push %ecx <== NOT EXECUTED 10dcaa: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10dcad: 03 45 a8 add -0x58(%ebp),%eax <== NOT EXECUTED 10dcb0: 50 push %eax <== NOT EXECUTED 10dcb1: e8 16 03 00 00 call 10dfcc <== NOT EXECUTED i += len; 10dcb6: 8b 75 f0 mov -0x10(%ebp),%esi <== NOT EXECUTED 10dcb9: 89 75 a4 mov %esi,-0x5c(%ebp) <== NOT EXECUTED if ( !pathloc->node_access ) 10dcbc: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10dcbf: 8b 17 mov (%edi),%edx <== NOT EXECUTED 10dcc1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dcc4: 85 d2 test %edx,%edx <== NOT EXECUTED 10dcc6: 0f 84 22 01 00 00 je 10ddee <== NOT EXECUTED /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10dccc: 85 c0 test %eax,%eax <== NOT EXECUTED 10dcce: 75 1c jne 10dcec <== NOT EXECUTED pathloc->node_access = node; break; case IMFS_NO_MORE_PATH: rtems_set_errno_and_return_minus_one( EEXIST ); 10dcd0: e8 e3 24 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10dcd5: c7 00 11 00 00 00 movl $0x11,(%eax) <== NOT EXECUTED 10dcdb: ba ff ff ff ff mov $0xffffffff,%edx <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10dce0: 89 d0 mov %edx,%eax <== NOT EXECUTED 10dce2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dce5: 5b pop %ebx <== NOT EXECUTED 10dce6: 5e pop %esi <== NOT EXECUTED 10dce7: 5f pop %edi <== NOT EXECUTED 10dce8: c9 leave <== NOT EXECUTED 10dce9: c3 ret <== NOT EXECUTED 10dcea: 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 ) 10dcec: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) <== NOT EXECUTED 10dcf0: 0f 84 12 01 00 00 je 10de08 <== NOT EXECUTED 10dcf6: 89 d3 mov %edx,%ebx <== NOT EXECUTED */ while( !done ) { type = IMFS_get_token( &path[i], token, &len ); i += len; 10dcf8: 8b 4d a4 mov -0x5c(%ebp),%ecx <== NOT EXECUTED 10dcfb: 01 4d a8 add %ecx,-0x58(%ebp) <== 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 ) { 10dcfe: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10dd01: 0f 84 89 00 00 00 je 10dd90 <== NOT EXECUTED 10dd07: 76 27 jbe 10dd30 <== NOT EXECUTED 10dd09: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10dd0c: 74 2e je 10dd3c <== NOT EXECUTED 10dd0e: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10dd11: 75 8e jne 10dca1 <== 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 ); 10dd13: e8 a0 24 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10dd18: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED 10dd1e: ba ff ff ff ff mov $0xffffffff,%edx <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10dd23: 89 d0 mov %edx,%eax <== NOT EXECUTED 10dd25: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dd28: 5b pop %ebx <== NOT EXECUTED 10dd29: 5e pop %esi <== NOT EXECUTED 10dd2a: 5f pop %edi <== NOT EXECUTED 10dd2b: c9 leave <== NOT EXECUTED 10dd2c: c3 ret <== NOT EXECUTED 10dd2d: 8d 76 00 lea 0x0(%esi),%esi <== 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 ) { 10dd30: 85 c0 test %eax,%eax <== NOT EXECUTED 10dd32: 74 9c je 10dcd0 <== NOT EXECUTED 10dd34: e9 68 ff ff ff jmp 10dca1 <== NOT EXECUTED 10dd39: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED pathloc->node_access = node; break; case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { 10dd3c: 8b 42 4c mov 0x4c(%edx),%eax <== NOT EXECUTED 10dd3f: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10dd42: 0f 84 66 01 00 00 je 10deae <== NOT EXECUTED result = IMFS_evaluate_link( pathloc, 0 ); if ( result == -1 ) return -1; } else if ( node->type == IMFS_SYM_LINK ) { 10dd48: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10dd4b: 0f 84 82 01 00 00 je 10ded3 <== NOT EXECUTED if ( result == -1 ) return -1; } node = pathloc->node_access; if ( !node ) 10dd51: 85 d2 test %edx,%edx <== NOT EXECUTED 10dd53: 0f 84 01 01 00 00 je 10de5a <== NOT EXECUTED /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10dd59: 83 7a 4c 01 cmpl $0x1,0x4c(%edx) <== NOT EXECUTED 10dd5d: 0f 85 f7 00 00 00 jne 10de5a <== 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 ) { 10dd63: 8b 42 5c mov 0x5c(%edx),%eax <== NOT EXECUTED 10dd66: 85 c0 test %eax,%eax <== NOT EXECUTED 10dd68: 0f 85 01 01 00 00 jne 10de6f <== NOT EXECUTED /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10dd6e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dd71: 8d 75 bf lea -0x41(%ebp),%esi <== NOT EXECUTED 10dd74: 56 push %esi <== NOT EXECUTED 10dd75: 52 push %edx <== NOT EXECUTED 10dd76: e8 ad 01 00 00 call 10df28 <== NOT EXECUTED 10dd7b: 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 ) 10dd7d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dd80: 85 c0 test %eax,%eax <== NOT EXECUTED 10dd82: 74 3c je 10ddc0 <== NOT EXECUTED done = true; else pathloc->node_access = node; 10dd84: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10dd87: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10dd89: e9 13 ff ff ff jmp 10dca1 <== NOT EXECUTED 10dd8e: 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 ) 10dd90: a1 54 c8 11 00 mov 0x11c854,%eax <== NOT EXECUTED 10dd95: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10dd98: 0f 84 03 ff ff ff je 10dca1 <== NOT EXECUTED /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){ 10dd9e: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10dda1: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 10dda4: 3b 50 18 cmp 0x18(%eax),%edx <== NOT EXECUTED 10dda7: 0f 84 4b 01 00 00 je 10def8 <== NOT EXECUTED *pathloc = newloc; return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); } } else { if ( !node->Parent ) 10ddad: 8b 5a 08 mov 0x8(%edx),%ebx <== NOT EXECUTED 10ddb0: 85 db test %ebx,%ebx <== NOT EXECUTED 10ddb2: 74 3a je 10ddee <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOENT ); node = node->Parent; } pathloc->node_access = node; 10ddb4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10ddb7: 89 1e mov %ebx,(%esi) <== NOT EXECUTED 10ddb9: e9 e3 fe ff ff jmp 10dca1 <== NOT EXECUTED 10ddbe: 66 90 xchg %ax,%ax <== NOT EXECUTED case IMFS_CURRENT_DIR: break; } } *name = &path[ i - len ]; 10ddc0: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 10ddc3: 2b 45 f0 sub -0x10(%ebp),%eax <== NOT EXECUTED 10ddc6: 03 45 08 add 0x8(%ebp),%eax <== NOT EXECUTED 10ddc9: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10ddcc: 89 02 mov %eax,(%edx) <== 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++) { 10ddce: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ddd1: 03 45 a8 add -0x58(%ebp),%eax <== NOT EXECUTED 10ddd4: 8a 10 mov (%eax),%dl <== NOT EXECUTED 10ddd6: 84 d2 test %dl,%dl <== NOT EXECUTED 10ddd8: 75 0a jne 10dde4 <== NOT EXECUTED 10ddda: eb 54 jmp 10de30 <== NOT EXECUTED 10dddc: 8a 50 01 mov 0x1(%eax),%dl <== NOT EXECUTED 10dddf: 40 inc %eax <== NOT EXECUTED 10dde0: 84 d2 test %dl,%dl <== NOT EXECUTED 10dde2: 74 4c je 10de30 <== NOT EXECUTED if ( !IMFS_is_separator( path[ i ] ) ) 10dde4: 80 fa 2f cmp $0x2f,%dl <== NOT EXECUTED 10dde7: 74 f3 je 10dddc <== NOT EXECUTED 10dde9: 80 fa 5c cmp $0x5c,%dl <== NOT EXECUTED 10ddec: 74 ee je 10dddc <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOENT ); 10ddee: e8 c5 23 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10ddf3: c7 00 02 00 00 00 movl $0x2,(%eax) <== NOT EXECUTED 10ddf9: ba ff ff ff ff mov $0xffffffff,%edx <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10ddfe: 89 d0 mov %edx,%eax <== NOT EXECUTED 10de00: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10de03: 5b pop %ebx <== NOT EXECUTED 10de04: 5e pop %esi <== NOT EXECUTED 10de05: 5f pop %edi <== NOT EXECUTED 10de06: c9 leave <== NOT EXECUTED 10de07: c3 ret <== NOT EXECUTED if ( !rtems_libio_is_valid_perms( flags ) ) { assert( 0 ); rtems_set_errno_and_return_minus_one( EIO ); } jnode = node->node_access; 10de08: 89 d3 mov %edx,%ebx <== 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 ) 10de0a: f6 42 30 40 testb $0x40,0x30(%edx) <== NOT EXECUTED 10de0e: 0f 85 e4 fe ff ff jne 10dcf8 <== NOT EXECUTED /* * We must have Write and execute permission on the returned node. */ if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) rtems_set_errno_and_return_minus_one( EACCES ); 10de14: e8 9f 23 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10de19: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10de1f: ba ff ff ff ff mov $0xffffffff,%edx <== NOT EXECUTED return result; } 10de24: 89 d0 mov %edx,%eax <== NOT EXECUTED 10de26: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10de29: 5b pop %ebx <== NOT EXECUTED 10de2a: 5e pop %esi <== NOT EXECUTED 10de2b: 5f pop %edi <== NOT EXECUTED 10de2c: c9 leave <== NOT EXECUTED 10de2d: c3 ret <== NOT EXECUTED 10de2e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Verify we can execute and write to this directory. */ result = IMFS_Set_handlers( pathloc ); 10de30: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10de33: e8 c8 f9 ff ff call 10d800 <== NOT EXECUTED 10de38: 89 c2 mov %eax,%edx <== NOT EXECUTED /* * The returned node must be a directory */ node = pathloc->node_access; 10de3a: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10de3d: 8b 01 mov (%ecx),%eax <== NOT EXECUTED if ( node->type != IMFS_DIRECTORY ) 10de3f: 59 pop %ecx <== NOT EXECUTED 10de40: 83 78 4c 01 cmpl $0x1,0x4c(%eax) <== NOT EXECUTED 10de44: 75 14 jne 10de5a <== 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 ) 10de46: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED 10de49: 25 c0 00 00 00 and $0xc0,%eax <== NOT EXECUTED 10de4e: 3d c0 00 00 00 cmp $0xc0,%eax <== NOT EXECUTED 10de53: 75 bf jne 10de14 <== NOT EXECUTED 10de55: e9 86 fe ff ff jmp 10dce0 <== 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 ); 10de5a: e8 59 23 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10de5f: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 10de65: ba ff ff ff ff mov $0xffffffff,%edx <== NOT EXECUTED 10de6a: e9 71 fe ff ff jmp 10dce0 <== 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; 10de6f: 8d 55 e0 lea -0x20(%ebp),%edx <== NOT EXECUTED 10de72: 83 c0 18 add $0x18,%eax <== NOT EXECUTED 10de75: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10de7a: 89 d7 mov %edx,%edi <== NOT EXECUTED 10de7c: 89 c6 mov %eax,%esi <== NOT EXECUTED 10de7e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10de80: b1 04 mov $0x4,%cl <== NOT EXECUTED 10de82: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10de85: 89 d6 mov %edx,%esi <== NOT EXECUTED 10de87: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10de89: 53 push %ebx <== NOT EXECUTED 10de8a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10de8d: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10de90: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10de93: 50 push %eax <== NOT EXECUTED 10de94: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10de97: 29 4d a8 sub %ecx,-0x58(%ebp) <== NOT EXECUTED 10de9a: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10de9d: 03 45 a8 add -0x58(%ebp),%eax <== NOT EXECUTED 10dea0: 50 push %eax <== NOT EXECUTED 10dea1: ff 52 04 call *0x4(%edx) <== NOT EXECUTED 10dea4: 89 c2 mov %eax,%edx <== NOT EXECUTED 10dea6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dea9: e9 32 fe ff ff jmp 10dce0 <== NOT EXECUTED case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { result = IMFS_evaluate_link( pathloc, 0 ); 10deae: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10deb1: 6a 00 push $0x0 <== NOT EXECUTED 10deb3: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10deb6: e8 25 fd ff ff call 10dbe0 <== NOT EXECUTED 10debb: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( result == -1 ) 10debd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dec0: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10dec3: 0f 84 17 fe ff ff je 10dce0 <== NOT EXECUTED 10dec9: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10decc: 8b 17 mov (%edi),%edx <== NOT EXECUTED 10dece: e9 7e fe ff ff jmp 10dd51 <== NOT EXECUTED return -1; } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_link( pathloc, 0 ); 10ded3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ded6: 6a 00 push $0x0 <== NOT EXECUTED 10ded8: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dedb: e8 00 fd ff ff call 10dbe0 <== NOT EXECUTED 10dee0: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( result == -1 ) 10dee2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dee5: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10dee8: 0f 84 f2 fd ff ff je 10dce0 <== NOT EXECUTED 10deee: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10def1: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10def3: e9 59 fe ff ff jmp 10dd51 <== NOT EXECUTED if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; } else { newloc = pathloc->mt_entry->mt_point_node; 10def8: 8d 5d e0 lea -0x20(%ebp),%ebx <== NOT EXECUTED 10defb: 8d 50 08 lea 0x8(%eax),%edx <== NOT EXECUTED 10defe: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10df03: 89 df mov %ebx,%edi <== NOT EXECUTED 10df05: 89 d6 mov %edx,%esi <== NOT EXECUTED 10df07: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10df09: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10df0b: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10df0e: 89 de mov %ebx,%esi <== NOT EXECUTED 10df10: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10df12: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10df14: 56 push %esi <== NOT EXECUTED 10df15: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10df18: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10df1b: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10df1e: 50 push %eax <== NOT EXECUTED 10df1f: 8b 4d a4 mov -0x5c(%ebp),%ecx <== NOT EXECUTED 10df22: e9 70 ff ff ff jmp 10de97 <== NOT EXECUTED 0010d870 : int IMFS_evaluate_hard_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10d870: 55 push %ebp <== NOT EXECUTED 10d871: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d873: 53 push %ebx <== NOT EXECUTED 10d874: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d877: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *jnode = node->node_access; 10d87a: 8b 03 mov (%ebx),%eax <== NOT EXECUTED /* * Check for things that should never happen. */ if ( jnode->type != IMFS_HARD_LINK ) 10d87c: 83 78 4c 03 cmpl $0x3,0x4c(%eax) <== NOT EXECUTED 10d880: 75 39 jne 10d8bb <== NOT EXECUTED /* * Set the hard link value and the handlers. */ node->node_access = jnode->info.hard_link.link_node; 10d882: 8b 40 50 mov 0x50(%eax),%eax <== NOT EXECUTED 10d885: 89 03 mov %eax,(%ebx) <== NOT EXECUTED IMFS_Set_handlers( node ); 10d887: 53 push %ebx <== NOT EXECUTED 10d888: e8 73 ff ff ff call 10d800 <== 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 ) 10d88d: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10d890: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 10d893: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10d895: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED 10d898: 21 d0 and %edx,%eax <== NOT EXECUTED 10d89a: 59 pop %ecx <== NOT EXECUTED 10d89b: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10d89d: 74 15 je 10d8b4 <== 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 ); 10d89f: e8 14 29 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10d8a4: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10d8aa: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED return result; } 10d8af: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d8b2: c9 leave <== NOT EXECUTED 10d8b3: c3 ret <== 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 ) 10d8b4: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( !IMFS_evaluate_permission( node, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10d8b6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d8b9: c9 leave <== NOT EXECUTED 10d8ba: c3 ret <== NOT EXECUTED /* * Check for things that should never happen. */ if ( jnode->type != IMFS_HARD_LINK ) rtems_fatal_error_occurred (0xABCD0000); 10d8bb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d8be: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED 10d8c3: e8 78 d1 ff ff call 10aa40 <== NOT EXECUTED 0010dbe0 : int IMFS_evaluate_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10dbe0: 55 push %ebp <== NOT EXECUTED 10dbe1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dbe3: 57 push %edi <== NOT EXECUTED 10dbe4: 56 push %esi <== NOT EXECUTED 10dbe5: 53 push %ebx <== NOT EXECUTED 10dbe6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10dbe9: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10dbec: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10dbef: 8b 15 54 c8 11 00 mov 0x11c854,%edx <== NOT EXECUTED 10dbf5: eb 0e jmp 10dc05 <== NOT EXECUTED 10dbf7: 90 nop <== NOT EXECUTED */ if ( jnode->type == IMFS_HARD_LINK ) result = IMFS_evaluate_hard_link( node, flags ); else if (jnode->type == IMFS_SYM_LINK ) 10dbf8: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10dbfb: 74 53 je 10dc50 <== NOT EXECUTED result = IMFS_evaluate_sym_link( node, flags ); } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || ( jnode->type == IMFS_HARD_LINK ) ) ); 10dbfd: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED 10dc00: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10dc03: 77 3a ja 10dc3f <== NOT EXECUTED { IMFS_jnode_t *jnode; int result = 0; do { jnode = node->node_access; 10dc05: 8b 1e mov (%esi),%ebx <== NOT EXECUTED /* * Increment and check the link counter. */ rtems_filesystem_link_counts ++; 10dc07: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 10dc0a: 40 inc %eax <== NOT EXECUTED 10dc0b: 66 89 42 28 mov %ax,0x28(%edx) <== NOT EXECUTED if ( rtems_filesystem_link_counts > MAXSYMLINK ) { 10dc0f: 66 83 f8 05 cmp $0x5,%ax <== NOT EXECUTED 10dc13: 77 57 ja 10dc6c <== NOT EXECUTED /* * Follow the Link node. */ if ( jnode->type == IMFS_HARD_LINK ) 10dc15: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10dc18: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10dc1b: 75 db jne 10dbf8 <== NOT EXECUTED result = IMFS_evaluate_hard_link( node, flags ); 10dc1d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dc20: 57 push %edi <== NOT EXECUTED 10dc21: 56 push %esi <== NOT EXECUTED 10dc22: e8 49 fc ff ff call 10d870 <== NOT EXECUTED 10dc27: 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 ) ) ); 10dc2a: 85 c0 test %eax,%eax <== NOT EXECUTED 10dc2c: 75 33 jne 10dc61 <== NOT EXECUTED 10dc2e: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10dc31: 8b 15 54 c8 11 00 mov 0x11c854,%edx <== NOT EXECUTED 10dc37: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED 10dc3a: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10dc3d: 76 c6 jbe 10dc05 <== NOT EXECUTED 10dc3f: 31 c0 xor %eax,%eax <== NOT EXECUTED /* * Clear link counter. */ rtems_filesystem_link_counts = 0; 10dc41: 66 c7 42 28 00 00 movw $0x0,0x28(%edx) <== NOT EXECUTED return result; } 10dc47: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dc4a: 5b pop %ebx <== NOT EXECUTED 10dc4b: 5e pop %esi <== NOT EXECUTED 10dc4c: 5f pop %edi <== NOT EXECUTED 10dc4d: c9 leave <== NOT EXECUTED 10dc4e: c3 ret <== NOT EXECUTED 10dc4f: 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 ); 10dc50: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dc53: 57 push %edi <== NOT EXECUTED 10dc54: 56 push %esi <== NOT EXECUTED 10dc55: e8 6e fc ff ff call 10d8c8 <== NOT EXECUTED 10dc5a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || ( jnode->type == IMFS_HARD_LINK ) ) ); 10dc5d: 85 c0 test %eax,%eax <== NOT EXECUTED 10dc5f: 74 cd je 10dc2e <== NOT EXECUTED 10dc61: 8b 15 54 c8 11 00 mov 0x11c854,%edx <== NOT EXECUTED 10dc67: eb d8 jmp 10dc41 <== NOT EXECUTED 10dc69: 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; 10dc6c: 66 c7 42 28 00 00 movw $0x0,0x28(%edx) <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ELOOP ); 10dc72: e8 41 25 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10dc77: c7 00 5c 00 00 00 movl $0x5c,(%eax) <== NOT EXECUTED 10dc7d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED */ rtems_filesystem_link_counts = 0; return result; } 10dc82: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dc85: 5b pop %ebx <== NOT EXECUTED 10dc86: 5e pop %esi <== NOT EXECUTED 10dc87: 5f pop %edi <== NOT EXECUTED 10dc88: c9 leave <== NOT EXECUTED 10dc89: c3 ret <== NOT EXECUTED 0010d850 : int IMFS_evaluate_permission( rtems_filesystem_location_info_t *node, int flags ) { 10d850: 55 push %ebp <== NOT EXECUTED 10d851: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d853: 8b 45 0c mov 0xc(%ebp),%eax <== 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 ) 10d856: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 10d859: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10d85c: 8b 12 mov (%edx),%edx <== NOT EXECUTED 10d85e: 8b 52 30 mov 0x30(%edx),%edx <== NOT EXECUTED 10d861: 21 c2 and %eax,%edx <== NOT EXECUTED 10d863: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10d865: 0f 94 c0 sete %al <== NOT EXECUTED 10d868: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED return 1; return 0; } 10d86b: c9 leave <== NOT EXECUTED 10d86c: c3 ret <== NOT EXECUTED 0010d8c8 : int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10d8c8: 55 push %ebp <== NOT EXECUTED 10d8c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d8cb: 57 push %edi <== NOT EXECUTED 10d8cc: 56 push %esi <== NOT EXECUTED 10d8cd: 53 push %ebx <== NOT EXECUTED 10d8ce: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED IMFS_jnode_t *jnode = node->node_access; 10d8d1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d8d4: 8b 18 mov (%eax),%ebx <== NOT EXECUTED /* * Check for things that should never happen. */ if ( jnode->type != IMFS_SYM_LINK ) 10d8d6: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx) <== NOT EXECUTED 10d8da: 0f 85 8c 00 00 00 jne 10d96c <== NOT EXECUTED rtems_fatal_error_occurred (0xABCD0000); if ( !jnode->Parent ) 10d8e0: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10d8e3: 85 c0 test %eax,%eax <== NOT EXECUTED 10d8e5: 0f 84 8e 00 00 00 je 10d979 <== 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; 10d8eb: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10d8ee: 89 02 mov %eax,(%edx) <== NOT EXECUTED rtems_filesystem_get_sym_start_loc( 10d8f0: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10d8f3: 8a 10 mov (%eax),%dl <== NOT EXECUTED 10d8f5: 80 fa 2f cmp $0x2f,%dl <== NOT EXECUTED 10d8f8: 74 0e je 10d908 <== NOT EXECUTED 10d8fa: 80 fa 5c cmp $0x5c,%dl <== NOT EXECUTED 10d8fd: 74 09 je 10d908 <== NOT EXECUTED 10d8ff: 84 d2 test %dl,%dl <== NOT EXECUTED 10d901: 74 05 je 10d908 <== NOT EXECUTED 10d903: 31 d2 xor %edx,%edx <== NOT EXECUTED 10d905: eb 1b jmp 10d922 <== NOT EXECUTED 10d907: 90 nop <== NOT EXECUTED 10d908: a1 54 c8 11 00 mov 0x11c854,%eax <== NOT EXECUTED 10d90d: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 10d910: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10d915: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10d918: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10d91a: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10d91d: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED /* * Use eval path to evaluate the path of the symbolic link. */ result = IMFS_eval_path( 10d922: 53 push %ebx <== NOT EXECUTED 10d923: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d926: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d929: 01 d0 add %edx,%eax <== NOT EXECUTED 10d92b: 50 push %eax <== NOT EXECUTED 10d92c: e8 57 00 00 00 call 10d988 <== NOT EXECUTED 10d931: 89 c3 mov %eax,%ebx <== NOT EXECUTED &jnode->info.sym_link.name[i], flags, node ); IMFS_Set_handlers( node ); 10d933: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d936: e8 c5 fe ff ff call 10d800 <== 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 ) 10d93b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10d93e: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 10d941: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10d944: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10d946: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED 10d949: 21 d0 and %edx,%eax <== NOT EXECUTED 10d94b: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10d94e: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10d950: 74 10 je 10d962 <== 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 ); 10d952: e8 61 28 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10d957: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10d95d: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED return result; } 10d962: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d964: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d967: 5b pop %ebx <== NOT EXECUTED 10d968: 5e pop %esi <== NOT EXECUTED 10d969: 5f pop %edi <== NOT EXECUTED 10d96a: c9 leave <== NOT EXECUTED 10d96b: c3 ret <== NOT EXECUTED /* * Check for things that should never happen. */ if ( jnode->type != IMFS_SYM_LINK ) rtems_fatal_error_occurred (0xABCD0000); 10d96c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d96f: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED 10d974: e8 c7 d0 ff ff call 10aa40 <== NOT EXECUTED if ( !jnode->Parent ) rtems_fatal_error_occurred( 0xBAD00000 ); 10d979: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d97c: 68 00 00 d0 ba push $0xbad00000 <== NOT EXECUTED 10d981: e8 ba d0 ff ff call 10aa40 <== NOT EXECUTED 0010fba4 : int IMFS_fchmod( rtems_filesystem_location_info_t *loc, mode_t mode ) { 10fba4: 55 push %ebp <== NOT EXECUTED 10fba5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fba7: 53 push %ebx <== NOT EXECUTED 10fba8: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10fbab: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED IMFS_jnode_t *jnode; #if defined(RTEMS_POSIX_API) uid_t st_uid; #endif jnode = loc->node_access; 10fbae: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fbb1: 8b 18 mov (%eax),%ebx <== NOT EXECUTED #endif /* * Change only the RWX permissions on the jnode to mode. */ if ( mode & (~ (S_IRWXU | S_IRWXG | S_IRWXO ) ) ) 10fbb3: f7 c2 00 fe ff ff test $0xfffffe00,%edx <== NOT EXECUTED 10fbb9: 75 2d jne 10fbe8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EPERM ); jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO); jnode->st_mode |= mode; 10fbbb: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10fbbe: 25 00 fe ff ff and $0xfffffe00,%eax <== NOT EXECUTED 10fbc3: 09 c2 or %eax,%edx <== NOT EXECUTED 10fbc5: 89 53 30 mov %edx,0x30(%ebx) <== NOT EXECUTED IMFS_update_ctime( jnode ); 10fbc8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10fbcb: 6a 00 push $0x0 <== NOT EXECUTED 10fbcd: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10fbd0: 50 push %eax <== NOT EXECUTED 10fbd1: e8 16 ea ff ff call 10e5ec <== NOT EXECUTED 10fbd6: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10fbd9: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 10fbdc: 31 c0 xor %eax,%eax <== NOT EXECUTED 10fbde: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10fbe1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10fbe4: c9 leave <== NOT EXECUTED 10fbe5: c3 ret <== NOT EXECUTED 10fbe6: 66 90 xchg %ax,%ax <== 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 ); 10fbe8: e8 cb 05 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10fbed: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10fbf3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10fbf8: eb e7 jmp 10fbe1 <== NOT EXECUTED 0012eff0 : int IMFS_fcntl( int cmd, rtems_libio_t *iop ) { 12eff0: 55 push %ebp <== NOT EXECUTED 12eff1: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 12eff3: 31 c0 xor %eax,%eax <== NOT EXECUTED 12eff5: c9 leave <== NOT EXECUTED 12eff6: c3 ret <== NOT EXECUTED 0012eff8 : #include "imfs.h" int IMFS_fdatasync( rtems_libio_t *iop ) { 12eff8: 55 push %ebp <== NOT EXECUTED 12eff9: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 12effb: 31 c0 xor %eax,%eax <== NOT EXECUTED 12effd: c9 leave <== NOT EXECUTED 12effe: c3 ret <== NOT EXECUTED 0010df28 : IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) { 10df28: 55 push %ebp <== NOT EXECUTED 10df29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10df2b: 57 push %edi <== NOT EXECUTED 10df2c: 56 push %esi <== NOT EXECUTED 10df2d: 53 push %ebx <== NOT EXECUTED 10df2e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10df31: 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 ); 10df34: 85 db test %ebx,%ebx <== NOT EXECUTED 10df36: 74 50 je 10df88 <== NOT EXECUTED if ( !name ) 10df38: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10df3b: 85 c0 test %eax,%eax <== NOT EXECUTED 10df3d: 74 3d je 10df7c <== NOT EXECUTED /* * Check for "." and ".." */ if ( !strcmp( name, dotname ) ) 10df3f: bf f7 88 11 00 mov $0x1188f7,%edi <== NOT EXECUTED 10df44: b9 02 00 00 00 mov $0x2,%ecx <== NOT EXECUTED 10df49: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10df4c: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 10df4e: 75 0c jne 10df5c <== NOT EXECUTED if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10df50: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10df52: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10df55: 5b pop %ebx <== NOT EXECUTED 10df56: 5e pop %esi <== NOT EXECUTED 10df57: 5f pop %edi <== NOT EXECUTED 10df58: c9 leave <== NOT EXECUTED 10df59: c3 ret <== NOT EXECUTED 10df5a: 66 90 xchg %ax,%ax <== NOT EXECUTED */ if ( !strcmp( name, dotname ) ) return directory; if ( !strcmp( name, dotdotname ) ) 10df5c: bf f9 88 11 00 mov $0x1188f9,%edi <== NOT EXECUTED 10df61: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10df66: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10df69: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 10df6b: 75 31 jne 10df9e <== NOT EXECUTED return directory->Parent; 10df6d: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10df70: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10df72: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10df75: 5b pop %ebx <== NOT EXECUTED 10df76: 5e pop %esi <== NOT EXECUTED 10df77: 5f pop %edi <== NOT EXECUTED 10df78: c9 leave <== NOT EXECUTED 10df79: c3 ret <== NOT EXECUTED 10df7a: 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 ); 10df7c: 31 db xor %ebx,%ebx <== NOT EXECUTED if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10df7e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10df80: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10df83: 5b pop %ebx <== NOT EXECUTED 10df84: 5e pop %esi <== NOT EXECUTED 10df85: 5f pop %edi <== NOT EXECUTED 10df86: c9 leave <== NOT EXECUTED 10df87: c3 ret <== NOT EXECUTED /* * Check for fatal errors. A NULL directory show a problem in the * the IMFS code. */ assert( directory ); 10df88: 68 9c 88 11 00 push $0x11889c <== NOT EXECUTED 10df8d: 68 fc 88 11 00 push $0x1188fc <== NOT EXECUTED 10df92: 6a 2a push $0x2a <== NOT EXECUTED 10df94: 68 a8 88 11 00 push $0x1188a8 <== NOT EXECUTED 10df99: e8 ca 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; 10df9e: 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 10dfa1: 83 c3 54 add $0x54,%ebx <== NOT EXECUTED !rtems_chain_is_tail( the_chain, the_node ); 10dfa4: 39 df cmp %ebx,%edi <== NOT EXECUTED 10dfa6: 75 0a jne 10dfb2 <== NOT EXECUTED 10dfa8: eb d2 jmp 10df7c <== NOT EXECUTED 10dfaa: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->next ) { 10dfac: 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 ); 10dfae: 39 df cmp %ebx,%edi <== NOT EXECUTED 10dfb0: 74 ca je 10df7c <== NOT EXECUTED the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; if ( !strcmp( name, the_jnode->name ) ) 10dfb2: 8d 47 0c lea 0xc(%edi),%eax <== NOT EXECUTED 10dfb5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dfb8: 50 push %eax <== NOT EXECUTED 10dfb9: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dfbc: e8 9f 32 00 00 call 111260 <== NOT EXECUTED 10dfc1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dfc4: 85 c0 test %eax,%eax <== NOT EXECUTED 10dfc6: 75 e4 jne 10dfac <== NOT EXECUTED 10dfc8: 89 fb mov %edi,%ebx <== NOT EXECUTED 10dfca: eb 84 jmp 10df50 <== NOT EXECUTED 00122e74 : */ int IMFS_freenodinfo( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 122e74: 55 push %ebp <== NOT EXECUTED 122e75: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 122e77: 31 c0 xor %eax,%eax <== NOT EXECUTED 122e79: c9 leave <== NOT EXECUTED 122e7a: c3 ret <== NOT EXECUTED 00122e7c : ((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next)) int IMFS_fsunmount( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 122e7c: 55 push %ebp <== NOT EXECUTED 122e7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 122e7f: 57 push %edi <== NOT EXECUTED 122e80: 56 push %esi <== NOT EXECUTED 122e81: 53 push %ebx <== NOT EXECUTED 122e82: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 122e85: 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; 122e88: 8b 58 18 mov 0x18(%eax),%ebx <== NOT EXECUTED loc = temp_mt_entry->mt_fs_root; 122e8b: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 122e8e: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED 122e91: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 122e94: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 122e99: 89 d7 mov %edx,%edi <== NOT EXECUTED 122e9b: 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; 122e9d: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED do { next = jnode->Parent; 122ea4: 8b 73 08 mov 0x8(%ebx),%esi <== NOT EXECUTED loc.node_access = (void *)jnode; 122ea7: 89 5d e4 mov %ebx,-0x1c(%ebp) <== NOT EXECUTED IMFS_Set_handlers( &loc ); 122eaa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 122ead: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 122eb0: 50 push %eax <== NOT EXECUTED 122eb1: e8 96 f8 ff ff call 12274c <== NOT EXECUTED if ( jnode->type != IMFS_DIRECTORY ) { 122eb6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 122eb9: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) <== NOT EXECUTED 122ebd: 75 2d jne 122eec <== NOT EXECUTED result = IMFS_unlink( &loc ); if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { 122ebf: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 122ec2: 39 43 50 cmp %eax,0x50(%ebx) <== NOT EXECUTED 122ec5: 74 3c je 122f03 <== NOT EXECUTED result = IMFS_unlink( &loc ); if (result != 0) return -1; jnode = next; } if ( jnode != NULL ) { 122ec7: 85 db test %ebx,%ebx <== NOT EXECUTED 122ec9: 74 15 je 122ee0 <== NOT EXECUTED if ( jnode->type == IMFS_DIRECTORY ) { 122ecb: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) <== NOT EXECUTED 122ecf: 75 d3 jne 122ea4 <== NOT EXECUTED if ( jnode_has_children( jnode ) ) 122ed1: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 122ed4: 39 43 50 cmp %eax,0x50(%ebx) <== NOT EXECUTED 122ed7: 74 cb je 122ea4 <== NOT EXECUTED jnode = jnode_get_first_child( jnode ); 122ed9: 8b 5b 50 mov 0x50(%ebx),%ebx <== NOT EXECUTED } } } while (jnode != NULL); 122edc: 85 db test %ebx,%ebx <== NOT EXECUTED 122ede: 75 c4 jne 122ea4 <== NOT EXECUTED 122ee0: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 122ee2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 122ee5: 5b pop %ebx <== NOT EXECUTED 122ee6: 5e pop %esi <== NOT EXECUTED 122ee7: 5f pop %edi <== NOT EXECUTED 122ee8: c9 leave <== NOT EXECUTED 122ee9: c3 ret <== NOT EXECUTED 122eea: 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 ); 122eec: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 122eef: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 122ef2: 52 push %edx <== NOT EXECUTED 122ef3: e8 8c 7e fe ff call 10ad84 <== NOT EXECUTED if (result != 0) 122ef8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 122efb: 85 c0 test %eax,%eax <== NOT EXECUTED 122efd: 75 17 jne 122f16 <== NOT EXECUTED return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { result = IMFS_unlink( &loc ); if (result != 0) 122eff: 89 f3 mov %esi,%ebx <== NOT EXECUTED 122f01: eb c4 jmp 122ec7 <== NOT EXECUTED result = IMFS_unlink( &loc ); if (result != 0) return -1; jnode = next; } else if ( jnode_has_no_children( jnode ) ) { result = IMFS_unlink( &loc ); 122f03: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 122f06: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 122f09: 57 push %edi <== NOT EXECUTED 122f0a: e8 75 7e fe ff call 10ad84 <== NOT EXECUTED if (result != 0) 122f0f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 122f12: 85 c0 test %eax,%eax <== NOT EXECUTED 122f14: 74 e9 je 122eff <== NOT EXECUTED if ( jnode->type == IMFS_DIRECTORY ) { if ( jnode_has_children( jnode ) ) jnode = jnode_get_first_child( jnode ); } } } while (jnode != NULL); 122f16: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 122f1b: eb c5 jmp 122ee2 <== NOT EXECUTED 0010dfcc : IMFS_token_types IMFS_get_token( const char *path, char *token, int *token_len ) { 10dfcc: 55 push %ebp <== NOT EXECUTED 10dfcd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dfcf: 57 push %edi <== NOT EXECUTED 10dfd0: 56 push %esi <== NOT EXECUTED 10dfd1: 53 push %ebx <== NOT EXECUTED 10dfd2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dfd5: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10dfd8: 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]; 10dfdb: 8a 01 mov (%ecx),%al <== NOT EXECUTED while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) { 10dfdd: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 10dfdf: 0f 84 99 00 00 00 je 10e07e <== NOT EXECUTED 10dfe5: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 10dfe7: 0f 84 91 00 00 00 je 10e07e <== NOT EXECUTED 10dfed: 84 c0 test %al,%al <== NOT EXECUTED 10dfef: 0f 84 a2 00 00 00 je 10e097 <== NOT EXECUTED token[i] = c; 10dff5: 88 03 mov %al,(%ebx) <== NOT EXECUTED 10dff7: 31 d2 xor %edx,%edx <== NOT EXECUTED 10dff9: eb 06 jmp 10e001 <== NOT EXECUTED 10dffb: 90 nop <== NOT EXECUTED 10dffc: 88 04 13 mov %al,(%ebx,%edx,1) <== NOT EXECUTED if ( i == IMFS_NAME_MAX ) 10dfff: 74 3f je 10e040 <== NOT EXECUTED return IMFS_INVALID_TOKEN; if ( !IMFS_is_valid_name_char(c) ) type = IMFS_INVALID_TOKEN; c = path [++i]; 10e001: 42 inc %edx <== NOT EXECUTED 10e002: 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) ) { 10e005: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 10e007: 74 0d je 10e016 <== NOT EXECUTED 10e009: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 10e00b: 74 09 je 10e016 <== NOT EXECUTED 10e00d: 84 c0 test %al,%al <== NOT EXECUTED 10e00f: 74 05 je 10e016 <== NOT EXECUTED 10e011: 83 fa 20 cmp $0x20,%edx <== NOT EXECUTED 10e014: 7e e6 jle 10dffc <== NOT EXECUTED i++; type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; } } else if (token[ i-1 ] != '\0') { 10e016: 80 7c 13 ff 00 cmpb $0x0,-0x1(%ebx,%edx,1) <== NOT EXECUTED 10e01b: 75 33 jne 10e050 <== NOT EXECUTED /* * Set token_len to the number of characters copied. */ *token_len = i; 10e01d: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10e020: 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 ) 10e022: bf d3 83 11 00 mov $0x1183d3,%edi <== NOT EXECUTED 10e027: b9 03 00 00 00 mov $0x3,%ecx <== NOT EXECUTED 10e02c: 89 de mov %ebx,%esi <== NOT EXECUTED 10e02e: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 10e030: 75 26 jne 10e058 <== NOT EXECUTED 10e032: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; } return type; } 10e037: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10e03a: 5b pop %ebx <== NOT EXECUTED 10e03b: 5e pop %esi <== NOT EXECUTED 10e03c: 5f pop %edi <== NOT EXECUTED 10e03d: c9 leave <== NOT EXECUTED 10e03e: c3 ret <== NOT EXECUTED 10e03f: 90 nop <== NOT EXECUTED c = path[i]; while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) { token[i] = c; if ( i == IMFS_NAME_MAX ) 10e040: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; } return type; } 10e045: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10e048: 5b pop %ebx <== NOT EXECUTED 10e049: 5e pop %esi <== NOT EXECUTED 10e04a: 5f pop %edi <== NOT EXECUTED 10e04b: c9 leave <== NOT EXECUTED 10e04c: c3 ret <== NOT EXECUTED 10e04d: 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'; 10e050: c6 04 13 00 movb $0x0,(%ebx,%edx,1) <== NOT EXECUTED 10e054: eb c7 jmp 10e01d <== NOT EXECUTED 10e056: 66 90 xchg %ax,%ax <== NOT EXECUTED */ if ( type == IMFS_NAME ) { if ( strcmp( token, "..") == 0 ) type = IMFS_UP_DIR; else if ( strcmp( token, "." ) == 0 ) 10e058: bf d4 83 11 00 mov $0x1183d4,%edi <== NOT EXECUTED 10e05d: b9 02 00 00 00 mov $0x2,%ecx <== NOT EXECUTED 10e062: 89 de mov %ebx,%esi <== NOT EXECUTED 10e064: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 10e066: 0f 97 c0 seta %al <== NOT EXECUTED 10e069: 0f 92 c2 setb %dl <== NOT EXECUTED 10e06c: 28 d0 sub %dl,%al <== NOT EXECUTED 10e06e: 0f be c0 movsbl %al,%eax <== NOT EXECUTED 10e071: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10e074: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10e076: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10e079: 83 c0 03 add $0x3,%eax <== NOT EXECUTED 10e07c: eb b9 jmp 10e037 <== NOT EXECUTED /* * Copy a seperator into token. */ if ( i == 0 ) { token[i] = c; 10e07e: 88 03 mov %al,(%ebx) <== NOT EXECUTED 10e080: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10e085: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED /* * Set token_len to the number of characters copied. */ *token_len = i; 10e08a: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10e08d: 89 11 mov %edx,(%ecx) <== NOT EXECUTED else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; } return type; } 10e08f: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10e092: 5b pop %ebx <== NOT EXECUTED 10e093: 5e pop %esi <== NOT EXECUTED 10e094: 5f pop %edi <== NOT EXECUTED 10e095: c9 leave <== NOT EXECUTED 10e096: c3 ret <== NOT EXECUTED /* * Copy a seperator into token. */ if ( i == 0 ) { token[i] = c; 10e097: c6 03 00 movb $0x0,(%ebx) <== NOT EXECUTED 10e09a: 31 d2 xor %edx,%edx <== NOT EXECUTED 10e09c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e09e: eb ea jmp 10e08a <== 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 60 3b 14 00 push $0x143b60 <== NOT EXECUTED 10aa43: 68 e0 3b 14 00 push $0x143be0 <== NOT EXECUTED 10aa48: 68 80 10 14 00 push $0x141080 <== 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 0010e0a0 : 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 ) { 10e0a0: 55 push %ebp <== NOT EXECUTED 10e0a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e0a3: 57 push %edi <== NOT EXECUTED 10e0a4: 56 push %esi <== NOT EXECUTED 10e0a5: 53 push %ebx <== NOT EXECUTED 10e0a6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e0a9: 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, 10e0ac: 8b 0d e4 a3 11 00 mov 0x11a3e4,%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) { 10e0b2: 83 f9 10 cmp $0x10,%ecx <== NOT EXECUTED 10e0b5: 74 18 je 10e0cf <== NOT EXECUTED 10e0b7: ba 20 00 00 00 mov $0x20,%edx <== NOT EXECUTED 10e0bc: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e0be: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 10e0c0: 74 0d je 10e0cf <== NOT EXECUTED /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) { 10e0c2: d1 e2 shl %edx <== NOT EXECUTED 10e0c4: 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); 10e0c5: 83 f8 05 cmp $0x5,%eax <== NOT EXECUTED 10e0c8: 75 f4 jne 10e0be <== NOT EXECUTED 10e0ca: 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) 10e0cf: 89 0d 68 e7 11 00 mov %ecx,0x11e768 <== 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( 10e0d5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e0d8: 6a 00 push $0x0 <== NOT EXECUTED 10e0da: 68 ed 41 00 00 push $0x41ed <== NOT EXECUTED 10e0df: 68 06 85 11 00 push $0x118506 <== NOT EXECUTED 10e0e4: 6a 01 push $0x1 <== NOT EXECUTED 10e0e6: 6a 00 push $0x0 <== NOT EXECUTED 10e0e8: e8 6f 19 00 00 call 10fa5c <== NOT EXECUTED 10e0ed: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED "", ( S_IFDIR | 0755 ), NULL ); temp_mt_entry->mt_fs_root.handlers = directory_handlers; 10e0f0: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10e0f3: 89 43 1c mov %eax,0x1c(%ebx) <== NOT EXECUTED temp_mt_entry->mt_fs_root.ops = op_table; 10e0f6: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e0f9: 89 43 20 mov %eax,0x20(%ebx) <== NOT EXECUTED temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS; 10e0fc: 8d 7b 30 lea 0x30(%ebx),%edi <== NOT EXECUTED 10e0ff: be 60 8b 11 00 mov $0x118b60,%esi <== NOT EXECUTED 10e104: b9 0c 00 00 00 mov $0xc,%ecx <== NOT EXECUTED 10e109: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* * Create custom file system data. */ fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) ); 10e10b: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10e10e: 6a 0c push $0xc <== NOT EXECUTED 10e110: 6a 01 push $0x1 <== NOT EXECUTED 10e112: e8 3d 03 00 00 call 10e454 <== NOT EXECUTED if ( !fs_info ){ 10e117: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e11a: 85 c0 test %eax,%eax <== NOT EXECUTED 10e11c: 74 29 je 10e147 <== 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; 10e11e: 89 43 2c mov %eax,0x2c(%ebx) <== NOT EXECUTED /* * Set st_ino for the root to 1. */ fs_info->ino_count = 1; 10e121: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED fs_info->memfile_handlers = memfile_handlers; 10e127: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10e12a: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED fs_info->directory_handlers = directory_handlers; 10e12d: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10e130: 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; 10e133: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10e136: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax) <== NOT EXECUTED 10e13d: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10e13f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e142: 5b pop %ebx <== NOT EXECUTED 10e143: 5e pop %esi <== NOT EXECUTED 10e144: 5f pop %edi <== NOT EXECUTED 10e145: c9 leave <== NOT EXECUTED 10e146: 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); 10e147: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e14a: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10e14d: e8 4e 8f ff ff call 1070a0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(ENOMEM); 10e152: e8 61 20 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10e157: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10e15d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e162: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e165: eb d8 jmp 10e13f <== 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 a7 7a 01 00 call 122604 <== 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 4f 62 02 00 call 130de0 <__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 3d 62 02 00 call 130de0 <__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 00129630 : MEMFILE_STATIC int IMFS_memfile_addblock( IMFS_jnode_t *the_jnode, unsigned int block ) { 129630: 55 push %ebp <== NOT EXECUTED 129631: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129633: 53 push %ebx <== NOT EXECUTED 129634: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 129637: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED block_p memory; block_p *block_entry_ptr; assert( the_jnode ); 12963a: 85 c0 test %eax,%eax <== NOT EXECUTED 12963c: 74 37 je 129675 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 12963e: 83 78 4c 05 cmpl $0x5,0x4c(%eax) <== NOT EXECUTED 129642: 75 4a jne 12968e <== 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 ); 129644: 52 push %edx <== NOT EXECUTED 129645: 6a 01 push $0x1 <== NOT EXECUTED 129647: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 12964a: 50 push %eax <== NOT EXECUTED 12964b: e8 d4 fa ff ff call 129124 <== NOT EXECUTED 129650: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( *block_entry_ptr ) 129652: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129655: 8b 00 mov (%eax),%eax <== NOT EXECUTED 129657: 85 c0 test %eax,%eax <== NOT EXECUTED 129659: 74 09 je 129664 <== NOT EXECUTED #endif memory = memfile_alloc_block(); if ( !memory ) return 1; *block_entry_ptr = memory; 12965b: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 12965d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 129660: c9 leave <== NOT EXECUTED 129661: c3 ret <== NOT EXECUTED 129662: 66 90 xchg %ax,%ax <== NOT EXECUTED #if 0 fprintf(stdout, "%d %p", block, block_entry_ptr ); fflush(stdout); #endif memory = memfile_alloc_block(); 129664: e8 97 fa ff ff call 129100 <== NOT EXECUTED if ( !memory ) 129669: 85 c0 test %eax,%eax <== NOT EXECUTED 12966b: 74 04 je 129671 <== NOT EXECUTED return 1; *block_entry_ptr = memory; 12966d: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 12966f: eb ea jmp 12965b <== NOT EXECUTED fprintf(stdout, "%d %p", block, block_entry_ptr ); fflush(stdout); #endif memory = memfile_alloc_block(); if ( !memory ) 129671: b0 01 mov $0x1,%al <== NOT EXECUTED 129673: eb e8 jmp 12965d <== NOT EXECUTED ) { block_p memory; block_p *block_entry_ptr; assert( the_jnode ); 129675: 68 6d 43 14 00 push $0x14436d <== NOT EXECUTED 12967a: 68 c5 44 14 00 push $0x1444c5 <== NOT EXECUTED 12967f: 68 69 01 00 00 push $0x169 <== NOT EXECUTED 129684: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 129689: e8 1e 19 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 ); 12968e: 68 e0 43 14 00 push $0x1443e0 <== NOT EXECUTED 129693: 68 c5 44 14 00 push $0x1444c5 <== NOT EXECUTED 129698: 68 6d 01 00 00 push $0x16d <== NOT EXECUTED 12969d: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 1296a2: e8 05 19 fe ff call 10afac <__assert_func> <== NOT EXECUTED 001296a8 : MEMFILE_STATIC int IMFS_memfile_extend( IMFS_jnode_t *the_jnode, off_t new_length ) { 1296a8: 55 push %ebp <== NOT EXECUTED 1296a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1296ab: 57 push %edi <== NOT EXECUTED 1296ac: 56 push %esi <== NOT EXECUTED 1296ad: 53 push %ebx <== NOT EXECUTED 1296ae: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 1296b1: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1296b4: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1296b6: 0f 84 c2 00 00 00 je 12977e <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 1296bc: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1296bf: 83 78 4c 05 cmpl $0x5,0x4c(%eax) <== NOT EXECUTED 1296c3: 0f 85 ce 00 00 00 jne 129797 <== NOT EXECUTED if ( the_jnode->type != IMFS_MEMORY_FILE ) rtems_set_errno_and_return_minus_one( EIO ); if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE ) 1296c9: 8b 0d b0 de 14 00 mov 0x14deb0,%ecx <== NOT EXECUTED 1296cf: 89 ca mov %ecx,%edx <== NOT EXECUTED 1296d1: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED 1296d4: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 1296d7: 0f af c2 imul %edx,%eax <== NOT EXECUTED 1296da: 40 inc %eax <== NOT EXECUTED 1296db: 0f af c2 imul %edx,%eax <== NOT EXECUTED 1296de: 48 dec %eax <== NOT EXECUTED 1296df: 0f af c1 imul %ecx,%eax <== NOT EXECUTED 1296e2: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 1296e5: 0f 83 81 00 00 00 jae 12976c <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); if ( new_length <= the_jnode->info.file.size ) 1296eb: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1296ee: 8b 5a 50 mov 0x50(%edx),%ebx <== NOT EXECUTED 1296f1: 39 5d 0c cmp %ebx,0xc(%ebp) <== NOT EXECUTED 1296f4: 7e 3f jle 129735 <== NOT EXECUTED /* * Calculate the number of range of blocks to allocate */ new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK; 1296f6: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1296f9: 99 cltd <== NOT EXECUTED 1296fa: f7 f9 idiv %ecx <== NOT EXECUTED 1296fc: 89 c6 mov %eax,%esi <== NOT EXECUTED old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK; 1296fe: 89 d8 mov %ebx,%eax <== NOT EXECUTED 129700: 99 cltd <== NOT EXECUTED 129701: f7 f9 idiv %ecx <== NOT EXECUTED 129703: 89 c7 mov %eax,%edi <== NOT EXECUTED /* * Now allocate each of those blocks. */ for ( block=old_blocks ; block<=new_blocks ; block++ ) { 129705: 39 c6 cmp %eax,%esi <== NOT EXECUTED 129707: 72 23 jb 12972c <== NOT EXECUTED 129709: 89 c3 mov %eax,%ebx <== NOT EXECUTED 12970b: eb 08 jmp 129715 <== NOT EXECUTED 12970d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 129710: 43 inc %ebx <== NOT EXECUTED 129711: 39 de cmp %ebx,%esi <== NOT EXECUTED 129713: 72 17 jb 12972c <== NOT EXECUTED if ( IMFS_memfile_addblock( the_jnode, block ) ) { 129715: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129718: 53 push %ebx <== NOT EXECUTED 129719: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12971c: e8 0f ff ff ff call 129630 <== NOT EXECUTED 129721: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129724: 85 c0 test %eax,%eax <== NOT EXECUTED 129726: 74 e8 je 129710 <== NOT EXECUTED 129728: eb 26 jmp 129750 <== NOT EXECUTED 12972a: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Set the new length of the file. */ the_jnode->info.file.size = new_length; 12972c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 12972f: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 129732: 89 42 50 mov %eax,0x50(%edx) <== NOT EXECUTED 129735: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 129737: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12973a: 5b pop %ebx <== NOT EXECUTED 12973b: 5e pop %esi <== NOT EXECUTED 12973c: 5f pop %edi <== NOT EXECUTED 12973d: c9 leave <== NOT EXECUTED 12973e: c3 ret <== NOT EXECUTED 12973f: 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 ); 129740: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129743: 53 push %ebx <== NOT EXECUTED 129744: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 129747: e8 bc fb ff ff call 129308 <== 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-- ) { 12974c: 4b dec %ebx <== NOT EXECUTED 12974d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129750: 39 df cmp %ebx,%edi <== NOT EXECUTED 129752: 76 ec jbe 129740 <== NOT EXECUTED IMFS_memfile_remove_block( the_jnode, block ); } rtems_set_errno_and_return_minus_one( ENOSPC ); 129754: e8 87 76 00 00 call 130de0 <__errno> <== NOT EXECUTED 129759: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 12975f: 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; } 129764: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 129767: 5b pop %ebx <== NOT EXECUTED 129768: 5e pop %esi <== NOT EXECUTED 129769: 5f pop %edi <== NOT EXECUTED 12976a: c9 leave <== NOT EXECUTED 12976b: 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 ); 12976c: e8 6f 76 00 00 call 130de0 <__errno> <== NOT EXECUTED 129771: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 129777: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12977c: eb b9 jmp 129737 <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 12977e: 68 6d 43 14 00 push $0x14436d <== NOT EXECUTED 129783: 68 db 44 14 00 push $0x1444db <== NOT EXECUTED 129788: 68 31 01 00 00 push $0x131 <== NOT EXECUTED 12978d: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 129792: e8 15 18 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 ); 129797: 68 e0 43 14 00 push $0x1443e0 <== NOT EXECUTED 12979c: 68 db 44 14 00 push $0x1444db <== NOT EXECUTED 1297a1: 68 35 01 00 00 push $0x135 <== NOT EXECUTED 1297a6: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 1297ab: e8 fc 17 fe ff call 10afac <__assert_func> <== NOT EXECUTED 00129124 : #endif IMFS_jnode_t *the_jnode, unsigned int block, int malloc_it ) { 129124: 55 push %ebp <== NOT EXECUTED 129125: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129127: 57 push %edi <== NOT EXECUTED 129128: 56 push %esi <== NOT EXECUTED 129129: 53 push %ebx <== NOT EXECUTED 12912a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12912d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 129130: 85 db test %ebx,%ebx <== NOT EXECUTED 129132: 0f 84 8c 00 00 00 je 1291c4 <== NOT EXECUTED if ( !the_jnode ) return NULL; assert( the_jnode->type == IMFS_MEMORY_FILE ); 129138: 83 7b 4c 05 cmpl $0x5,0x4c(%ebx) <== NOT EXECUTED 12913c: 0f 85 9b 00 00 00 jne 1291dd <== NOT EXECUTED /* * Is the block number in the simple indirect portion? */ if ( my_block <= LAST_INDIRECT ) { 129142: 8b 35 b0 de 14 00 mov 0x14deb0,%esi <== NOT EXECUTED 129148: c1 ee 02 shr $0x2,%esi <== NOT EXECUTED 12914b: 8d 46 ff lea -0x1(%esi),%eax <== NOT EXECUTED 12914e: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 129151: 76 51 jbe 1291a4 <== NOT EXECUTED /* * Is the block number in the doubly indirect portion? */ if ( my_block <= LAST_DOUBLY_INDIRECT ) { 129153: 8d 4e 01 lea 0x1(%esi),%ecx <== NOT EXECUTED 129156: 0f af ce imul %esi,%ecx <== NOT EXECUTED 129159: 8d 41 ff lea -0x1(%ecx),%eax <== NOT EXECUTED 12915c: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 12915f: 0f 87 9f 00 00 00 ja 129204 <== NOT EXECUTED #if 0 fprintf(stdout, "(d %d) ", block ); fflush(stdout); #endif my_block -= FIRST_DOUBLY_INDIRECT; 129165: 29 75 0c sub %esi,0xc(%ebp) <== NOT EXECUTED singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 129168: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 12916b: 31 d2 xor %edx,%edx <== NOT EXECUTED 12916d: f7 f6 div %esi <== NOT EXECUTED 12916f: 89 d7 mov %edx,%edi <== NOT EXECUTED 129171: 89 c6 mov %eax,%esi <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; p = info->doubly_indirect; 129173: 8b 43 58 mov 0x58(%ebx),%eax <== NOT EXECUTED if ( malloc_it ) { 129176: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 129179: 85 c9 test %ecx,%ecx <== NOT EXECUTED 12917b: 0f 84 db 00 00 00 je 12925c <== NOT EXECUTED if ( !p ) { 129181: 85 c0 test %eax,%eax <== NOT EXECUTED 129183: 0f 84 f7 00 00 00 je 129280 <== NOT EXECUTED if ( !p ) return 0; info->doubly_indirect = p; } p1 = (block_p *)p[ doubly ]; 129189: 8d 1c b0 lea (%eax,%esi,4),%ebx <== NOT EXECUTED 12918c: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p1 ) { 12918e: 85 c0 test %eax,%eax <== NOT EXECUTED 129190: 0f 84 ff 00 00 00 je 129295 <== 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 ]; 129196: 8d 04 b8 lea (%eax,%edi,4),%eax <== NOT EXECUTED /* * This means the requested block number is out of range. */ return 0; } 129199: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12919c: 5b pop %ebx <== NOT EXECUTED 12919d: 5e pop %esi <== NOT EXECUTED 12919e: 5f pop %edi <== NOT EXECUTED 12919f: c9 leave <== NOT EXECUTED 1291a0: c3 ret <== NOT EXECUTED 1291a1: 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; 1291a4: 8b 43 54 mov 0x54(%ebx),%eax <== NOT EXECUTED if ( malloc_it ) { 1291a7: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 1291aa: 85 f6 test %esi,%esi <== NOT EXECUTED 1291ac: 74 48 je 1291f6 <== NOT EXECUTED if ( !p ) { 1291ae: 85 c0 test %eax,%eax <== NOT EXECUTED 1291b0: 0f 84 b9 00 00 00 je 12926f <== NOT EXECUTED } if ( !p ) return 0; return &info->indirect[ my_block ]; 1291b6: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 1291b9: 8d 04 90 lea (%eax,%edx,4),%eax <== NOT EXECUTED /* * This means the requested block number is out of range. */ return 0; } 1291bc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1291bf: 5b pop %ebx <== NOT EXECUTED 1291c0: 5e pop %esi <== NOT EXECUTED 1291c1: 5f pop %edi <== NOT EXECUTED 1291c2: c9 leave <== NOT EXECUTED 1291c3: c3 ret <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 1291c4: 68 6d 43 14 00 push $0x14436d <== NOT EXECUTED 1291c9: 68 50 44 14 00 push $0x144450 <== NOT EXECUTED 1291ce: 68 86 03 00 00 push $0x386 <== NOT EXECUTED 1291d3: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 1291d8: e8 cf 1d fe ff call 10afac <__assert_func> <== NOT EXECUTED if ( !the_jnode ) return NULL; assert( the_jnode->type == IMFS_MEMORY_FILE ); 1291dd: 68 e0 43 14 00 push $0x1443e0 <== NOT EXECUTED 1291e2: 68 50 44 14 00 push $0x144450 <== NOT EXECUTED 1291e7: 68 8a 03 00 00 push $0x38a <== NOT EXECUTED 1291ec: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 1291f1: e8 b6 1d fe ff call 10afac <__assert_func> <== NOT EXECUTED info->indirect = p; } return &info->indirect[ my_block ]; } if ( !p ) 1291f6: 85 c0 test %eax,%eax <== NOT EXECUTED 1291f8: 75 bc jne 1291b6 <== NOT EXECUTED p2 = (block_p *)p1[ doubly ]; if ( !p ) return 0; return (block_p *)&p2[ singly ]; 1291fa: 31 c0 xor %eax,%eax <== NOT EXECUTED /* * This means the requested block number is out of range. */ return 0; } 1291fc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1291ff: 5b pop %ebx <== NOT EXECUTED 129200: 5e pop %esi <== NOT EXECUTED 129201: 5f pop %edi <== NOT EXECUTED 129202: c9 leave <== NOT EXECUTED 129203: c3 ret <== NOT EXECUTED #endif /* * Is the block number in the triply indirect portion? */ if ( my_block <= LAST_TRIPLY_INDIRECT ) { 129204: 8d 41 01 lea 0x1(%ecx),%eax <== NOT EXECUTED 129207: 0f af c6 imul %esi,%eax <== NOT EXECUTED 12920a: 48 dec %eax <== NOT EXECUTED 12920b: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 12920e: 77 ea ja 1291fa <== NOT EXECUTED my_block -= FIRST_TRIPLY_INDIRECT; 129210: 29 4d 0c sub %ecx,0xc(%ebp) <== NOT EXECUTED singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS; 129213: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 129216: 31 d2 xor %edx,%edx <== NOT EXECUTED 129218: f7 f6 div %esi <== NOT EXECUTED 12921a: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS; triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS; 12921d: 31 d2 xor %edx,%edx <== NOT EXECUTED 12921f: f7 f6 div %esi <== NOT EXECUTED 129221: 89 d7 mov %edx,%edi <== NOT EXECUTED 129223: 89 c6 mov %eax,%esi <== NOT EXECUTED doubly %= IMFS_MEMFILE_BLOCK_SLOTS; p = info->triply_indirect; 129225: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED if ( malloc_it ) { 129228: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 12922b: 85 d2 test %edx,%edx <== NOT EXECUTED 12922d: 74 7a je 1292a9 <== NOT EXECUTED if ( !p ) { 12922f: 85 c0 test %eax,%eax <== NOT EXECUTED 129231: 0f 84 93 00 00 00 je 1292ca <== NOT EXECUTED if ( !p ) return 0; info->triply_indirect = p; } p1 = (block_p *) p[ triply ]; 129237: 8d 1c b0 lea (%eax,%esi,4),%ebx <== NOT EXECUTED 12923a: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p1 ) { 12923c: 85 c0 test %eax,%eax <== NOT EXECUTED 12923e: 0f 84 af 00 00 00 je 1292f3 <== NOT EXECUTED if ( !p1 ) return 0; p[ triply ] = (block_p) p1; } p2 = (block_p *)p1[ doubly ]; 129244: 8d 1c b8 lea (%eax,%edi,4),%ebx <== NOT EXECUTED 129247: 8b 03 mov (%ebx),%eax <== NOT EXECUTED if ( !p2 ) { 129249: 85 c0 test %eax,%eax <== NOT EXECUTED 12924b: 0f 84 8e 00 00 00 je 1292df <== NOT EXECUTED p2 = memfile_alloc_block(); if ( !p2 ) return 0; p1[ doubly ] = (block_p) p2; } return (block_p *)&p2[ singly ]; 129251: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 129254: 8d 04 90 lea (%eax,%edx,4),%eax <== NOT EXECUTED 129257: e9 3d ff ff ff jmp 129199 <== NOT EXECUTED } return (block_p *)&p1[ singly ]; } if ( !p ) 12925c: 85 c0 test %eax,%eax <== NOT EXECUTED 12925e: 74 9a je 1291fa <== NOT EXECUTED return 0; p = (block_p *)p[ doubly ]; 129260: 8b 04 b0 mov (%eax,%esi,4),%eax <== NOT EXECUTED if ( !p ) 129263: 85 c0 test %eax,%eax <== NOT EXECUTED 129265: 0f 85 2b ff ff ff jne 129196 <== NOT EXECUTED p2 = (block_p *)p1[ doubly ]; if ( !p ) return 0; return (block_p *)&p2[ singly ]; 12926b: 31 c0 xor %eax,%eax <== NOT EXECUTED 12926d: eb 8d jmp 1291fc <== NOT EXECUTED p = info->indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 12926f: e8 8c fe ff ff call 129100 <== NOT EXECUTED if ( !p ) 129274: 85 c0 test %eax,%eax <== NOT EXECUTED 129276: 74 82 je 1291fa <== NOT EXECUTED return 0; info->indirect = p; 129278: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED 12927b: e9 36 ff ff ff jmp 1291b6 <== NOT EXECUTED p = info->doubly_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 129280: e8 7b fe ff ff call 129100 <== NOT EXECUTED if ( !p ) 129285: 85 c0 test %eax,%eax <== NOT EXECUTED 129287: 0f 84 6d ff ff ff je 1291fa <== NOT EXECUTED return 0; info->doubly_indirect = p; 12928d: 89 43 58 mov %eax,0x58(%ebx) <== NOT EXECUTED 129290: e9 f4 fe ff ff jmp 129189 <== NOT EXECUTED } p1 = (block_p *)p[ doubly ]; if ( !p1 ) { p1 = memfile_alloc_block(); 129295: e8 66 fe ff ff call 129100 <== NOT EXECUTED if ( !p1 ) 12929a: 85 c0 test %eax,%eax <== NOT EXECUTED 12929c: 0f 84 58 ff ff ff je 1291fa <== NOT EXECUTED return 0; p[ doubly ] = (block_p) p1; 1292a2: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 1292a4: e9 ed fe ff ff jmp 129196 <== NOT EXECUTED p1[ doubly ] = (block_p) p2; } return (block_p *)&p2[ singly ]; } if ( !p ) 1292a9: 85 c0 test %eax,%eax <== NOT EXECUTED 1292ab: 0f 84 49 ff ff ff je 1291fa <== 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 ]; 1292b1: 8b 14 b0 mov (%eax,%esi,4),%edx <== NOT EXECUTED if ( !p1 ) 1292b4: 85 d2 test %edx,%edx <== NOT EXECUTED 1292b6: 0f 84 3e ff ff ff je 1291fa <== NOT EXECUTED p2 = (block_p *)p1[ doubly ]; if ( !p ) return 0; return (block_p *)&p2[ singly ]; 1292bc: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1292bf: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 1292c2: 03 04 ba add (%edx,%edi,4),%eax <== NOT EXECUTED 1292c5: e9 cf fe ff ff jmp 129199 <== NOT EXECUTED p = info->triply_indirect; if ( malloc_it ) { if ( !p ) { p = memfile_alloc_block(); 1292ca: e8 31 fe ff ff call 129100 <== NOT EXECUTED if ( !p ) 1292cf: 85 c0 test %eax,%eax <== NOT EXECUTED 1292d1: 0f 84 23 ff ff ff je 1291fa <== NOT EXECUTED return 0; info->triply_indirect = p; 1292d7: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED 1292da: e9 58 ff ff ff jmp 129237 <== NOT EXECUTED p[ triply ] = (block_p) p1; } p2 = (block_p *)p1[ doubly ]; if ( !p2 ) { p2 = memfile_alloc_block(); 1292df: e8 1c fe ff ff call 129100 <== NOT EXECUTED if ( !p2 ) 1292e4: 85 c0 test %eax,%eax <== NOT EXECUTED 1292e6: 0f 84 0e ff ff ff je 1291fa <== NOT EXECUTED return 0; p1[ doubly ] = (block_p) p2; 1292ec: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 1292ee: e9 5e ff ff ff jmp 129251 <== NOT EXECUTED info->triply_indirect = p; } p1 = (block_p *) p[ triply ]; if ( !p1 ) { p1 = memfile_alloc_block(); 1292f3: e8 08 fe ff ff call 129100 <== NOT EXECUTED if ( !p1 ) 1292f8: 85 c0 test %eax,%eax <== NOT EXECUTED 1292fa: 0f 84 fa fe ff ff je 1291fa <== NOT EXECUTED return 0; p[ triply ] = (block_p) p1; 129300: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 129302: e9 3d ff ff ff jmp 129244 <== NOT EXECUTED 00129b4c : IMFS_jnode_t *the_jnode, off_t start, unsigned char *destination, unsigned int length ) { 129b4c: 55 push %ebp <== NOT EXECUTED 129b4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129b4f: 57 push %edi <== NOT EXECUTED 129b50: 56 push %esi <== NOT EXECUTED 129b51: 53 push %ebx <== NOT EXECUTED 129b52: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 129b55: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 129b58: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 129b5b: 85 ff test %edi,%edi <== NOT EXECUTED 129b5d: 0f 84 d3 01 00 00 je 129d36 <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE || 129b63: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129b66: 8b 48 4c mov 0x4c(%eax),%ecx <== NOT EXECUTED 129b69: 8d 41 fb lea -0x5(%ecx),%eax <== NOT EXECUTED 129b6c: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 129b6f: 0f 87 da 01 00 00 ja 129d4f <== NOT EXECUTED /* * Error checks on arguments */ assert( dest ); 129b75: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 129b78: 85 db test %ebx,%ebx <== NOT EXECUTED 129b7a: 0f 84 e8 01 00 00 je 129d68 <== NOT EXECUTED /* * If there is nothing to read, then quick exit. */ my_length = length; if ( !my_length ) 129b80: 85 f6 test %esi,%esi <== NOT EXECUTED 129b82: 0f 84 99 01 00 00 je 129d21 <== NOT EXECUTED /* * Linear files (as created from a tar file are easier to handle * than block files). */ if (the_jnode->type == IMFS_LINEAR_FILE) { 129b88: 83 f9 06 cmp $0x6,%ecx <== NOT EXECUTED 129b8b: 0f 84 2b 01 00 00 je 129cbc <== 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 ) 129b91: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 129b94: 8b 4f 50 mov 0x50(%edi),%ecx <== NOT EXECUTED 129b97: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 129b9a: 8d 04 16 lea (%esi,%edx,1),%eax <== NOT EXECUTED 129b9d: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 129b9f: 0f 87 c3 00 00 00 ja 129c68 <== NOT EXECUTED 129ba5: 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; 129ba8: 8b 1d b0 de 14 00 mov 0x14deb0,%ebx <== NOT EXECUTED 129bae: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 129bb1: 99 cltd <== NOT EXECUTED 129bb2: f7 fb idiv %ebx <== NOT EXECUTED 129bb4: 89 d6 mov %edx,%esi <== NOT EXECUTED 129bb6: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 129bb9: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED if ( start_offset ) { 129bbc: 85 d2 test %edx,%edx <== NOT EXECUTED 129bbe: 0f 85 b0 00 00 00 jne 129c74 <== NOT EXECUTED 129bc4: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 129bc7: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED 129bca: 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 ) { 129bd1: 39 5d d8 cmp %ebx,-0x28(%ebp) <== NOT EXECUTED 129bd4: 72 3b jb 129c11 <== NOT EXECUTED 129bd6: 66 90 xchg %ax,%ax <== NOT EXECUTED block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 129bd8: 52 push %edx <== NOT EXECUTED 129bd9: 6a 00 push $0x0 <== NOT EXECUTED 129bdb: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 129bde: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 129be1: e8 3e f5 ff ff call 129124 <== NOT EXECUTED assert( block_ptr ); 129be6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129be9: 85 c0 test %eax,%eax <== NOT EXECUTED 129beb: 0f 84 17 01 00 00 je 129d08 <== NOT EXECUTED if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], to_copy ); 129bf1: 8b 30 mov (%eax),%esi <== NOT EXECUTED 129bf3: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED 129bf6: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 129bf8: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED dest += to_copy; 129bfa: 89 7d e0 mov %edi,-0x20(%ebp) <== NOT EXECUTED block++; 129bfd: ff 45 d4 incl -0x2c(%ebp) <== NOT EXECUTED my_length -= to_copy; 129c00: 29 5d d8 sub %ebx,-0x28(%ebp) <== NOT EXECUTED copied += to_copy; 129c03: 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 ) { 129c06: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 129c09: 39 15 b0 de 14 00 cmp %edx,0x14deb0 <== NOT EXECUTED 129c0f: 76 c7 jbe 129bd8 <== NOT EXECUTED 129c11: 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 ) { 129c14: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 129c17: 85 c0 test %eax,%eax <== NOT EXECUTED 129c19: 74 26 je 129c41 <== NOT EXECUTED block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 129c1b: 50 push %eax <== NOT EXECUTED 129c1c: 6a 00 push $0x0 <== NOT EXECUTED 129c1e: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 129c21: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 129c24: e8 fb f4 ff ff call 129124 <== NOT EXECUTED assert( block_ptr ); 129c29: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129c2c: 85 c0 test %eax,%eax <== NOT EXECUTED 129c2e: 0f 84 66 01 00 00 je 129d9a <== NOT EXECUTED if ( !block_ptr ) return copied; memcpy( dest, &(*block_ptr)[ 0 ], my_length ); 129c34: 8b 30 mov (%eax),%esi <== NOT EXECUTED 129c36: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED 129c39: 8b 4d d8 mov -0x28(%ebp),%ecx <== NOT EXECUTED 129c3c: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED copied += my_length; 129c3e: 03 5d d8 add -0x28(%ebp),%ebx <== NOT EXECUTED } IMFS_update_atime( the_jnode ); 129c41: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129c44: 6a 00 push $0x0 <== NOT EXECUTED 129c46: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 129c49: 50 push %eax <== NOT EXECUTED 129c4a: e8 9d 17 fe ff call 10b3ec <== NOT EXECUTED 129c4f: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 129c52: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 129c55: 89 41 40 mov %eax,0x40(%ecx) <== NOT EXECUTED return copied; 129c58: 89 d8 mov %ebx,%eax <== NOT EXECUTED 129c5a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 129c5d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 129c60: 5b pop %ebx <== NOT EXECUTED 129c61: 5e pop %esi <== NOT EXECUTED 129c62: 5f pop %edi <== NOT EXECUTED 129c63: c9 leave <== NOT EXECUTED 129c64: c3 ret <== NOT EXECUTED 129c65: 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; 129c68: 2b 4d 0c sub 0xc(%ebp),%ecx <== NOT EXECUTED 129c6b: 89 4d d8 mov %ecx,-0x28(%ebp) <== NOT EXECUTED 129c6e: e9 35 ff ff ff jmp 129ba8 <== NOT EXECUTED 129c73: 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 ); 129c74: 51 push %ecx <== NOT EXECUTED 129c75: 6a 00 push $0x0 <== NOT EXECUTED 129c77: ff 75 cc pushl -0x34(%ebp) <== NOT EXECUTED 129c7a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 129c7d: e8 a2 f4 ff ff call 129124 <== NOT EXECUTED assert( block_ptr ); 129c82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129c85: 85 c0 test %eax,%eax <== NOT EXECUTED 129c87: 0f 84 f4 00 00 00 je 129d81 <== 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; 129c8d: 89 da mov %ebx,%edx <== NOT EXECUTED 129c8f: 29 f2 sub %esi,%edx <== NOT EXECUTED 129c91: 8b 5d d8 mov -0x28(%ebp),%ebx <== NOT EXECUTED 129c94: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 129c96: 77 6c ja 129d04 <== 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 ); 129c98: 03 30 add (%eax),%esi <== NOT EXECUTED dest += to_copy; 129c9a: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 129c9d: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 129c9f: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 129ca1: 89 7d e0 mov %edi,-0x20(%ebp) <== NOT EXECUTED block++; 129ca4: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 129ca7: 40 inc %eax <== NOT EXECUTED 129ca8: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED my_length -= to_copy; 129cab: 29 5d d8 sub %ebx,-0x28(%ebp) <== NOT EXECUTED 129cae: 89 5d dc mov %ebx,-0x24(%ebp) <== NOT EXECUTED 129cb1: 8b 1d b0 de 14 00 mov 0x14deb0,%ebx <== NOT EXECUTED 129cb7: e9 15 ff ff ff jmp 129bd1 <== 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)) 129cbc: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 129cbf: 8b 5a 50 mov 0x50(%edx),%ebx <== NOT EXECUTED 129cc2: 2b 5d 0c sub 0xc(%ebp),%ebx <== NOT EXECUTED 129cc5: 39 f3 cmp %esi,%ebx <== NOT EXECUTED 129cc7: 77 37 ja 129d00 <== NOT EXECUTED my_length = the_jnode->info.linearfile.size - start; memcpy(dest, &file_ptr[start], my_length); 129cc9: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 129ccc: 8b 49 54 mov 0x54(%ecx),%ecx <== NOT EXECUTED 129ccf: 01 4d 0c add %ecx,0xc(%ebp) <== NOT EXECUTED 129cd2: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 129cd5: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 129cd8: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 129cda: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED IMFS_update_atime( the_jnode ); 129cdc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129cdf: 6a 00 push $0x0 <== NOT EXECUTED 129ce1: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 129ce4: 50 push %eax <== NOT EXECUTED 129ce5: e8 02 17 fe ff call 10b3ec <== NOT EXECUTED 129cea: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 129ced: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 129cf0: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED return my_length; 129cf3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 129cf5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } IMFS_update_atime( the_jnode ); return copied; } 129cf8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 129cfb: 5b pop %ebx <== NOT EXECUTED 129cfc: 5e pop %esi <== NOT EXECUTED 129cfd: 5f pop %edi <== NOT EXECUTED 129cfe: c9 leave <== NOT EXECUTED 129cff: 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)) 129d00: 89 f3 mov %esi,%ebx <== NOT EXECUTED 129d02: eb c5 jmp 129cc9 <== 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; 129d04: 89 d3 mov %edx,%ebx <== NOT EXECUTED 129d06: eb 90 jmp 129c98 <== 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 ); 129d08: 68 83 43 14 00 push $0x144383 <== NOT EXECUTED 129d0d: 68 82 44 14 00 push $0x144482 <== NOT EXECUTED 129d12: 68 a5 02 00 00 push $0x2a5 <== NOT EXECUTED 129d17: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 129d1c: e8 8b 12 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 ); 129d21: e8 ba 70 00 00 call 130de0 <__errno> <== NOT EXECUTED 129d26: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 129d2c: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 129d31: e9 27 ff ff ff jmp 129c5d <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 129d36: 68 6d 43 14 00 push $0x14436d <== NOT EXECUTED 129d3b: 68 82 44 14 00 push $0x144482 <== NOT EXECUTED 129d40: 68 4a 02 00 00 push $0x24a <== NOT EXECUTED 129d45: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 129d4a: e8 5d 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 || 129d4f: 68 04 44 14 00 push $0x144404 <== NOT EXECUTED 129d54: 68 82 44 14 00 push $0x144482 <== NOT EXECUTED 129d59: 68 4f 02 00 00 push $0x24f <== NOT EXECUTED 129d5e: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 129d63: e8 44 12 fe ff call 10afac <__assert_func> <== NOT EXECUTED /* * Error checks on arguments */ assert( dest ); 129d68: 68 8d 43 14 00 push $0x14438d <== NOT EXECUTED 129d6d: 68 82 44 14 00 push $0x144482 <== NOT EXECUTED 129d72: 68 58 02 00 00 push $0x258 <== NOT EXECUTED 129d77: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 129d7c: e8 2b 12 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 ); 129d81: 68 83 43 14 00 push $0x144383 <== NOT EXECUTED 129d86: 68 82 44 14 00 push $0x144482 <== NOT EXECUTED 129d8b: 68 94 02 00 00 push $0x294 <== NOT EXECUTED 129d90: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 129d95: e8 12 12 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 ); 129d9a: 68 83 43 14 00 push $0x144383 <== NOT EXECUTED 129d9f: 68 82 44 14 00 push $0x144482 <== NOT EXECUTED 129da4: 68 b7 02 00 00 push $0x2b7 <== NOT EXECUTED 129da9: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 129dae: e8 f9 11 fe ff call 10afac <__assert_func> <== NOT EXECUTED 001293b0 : */ int IMFS_memfile_remove( IMFS_jnode_t *the_jnode ) { 1293b0: 55 push %ebp <== NOT EXECUTED 1293b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1293b3: 57 push %edi <== NOT EXECUTED 1293b4: 56 push %esi <== NOT EXECUTED 1293b5: 53 push %ebx <== NOT EXECUTED 1293b6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 1293b9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1293bc: 85 c0 test %eax,%eax <== NOT EXECUTED 1293be: 0f 84 68 01 00 00 je 12952c <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 1293c4: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1293c7: 83 78 4c 05 cmpl $0x5,0x4c(%eax) <== NOT EXECUTED 1293cb: 0f 85 74 01 00 00 jne 129545 <== 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; 1293d1: 8b 15 b0 de 14 00 mov 0x14deb0,%edx <== NOT EXECUTED 1293d7: c1 ea 02 shr $0x2,%edx <== NOT EXECUTED 1293da: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED * + triply indirect */ info = &the_jnode->info.file; if ( info->indirect ) { 1293dd: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 1293e0: 8b 7e 54 mov 0x54(%esi),%edi <== NOT EXECUTED 1293e3: 85 ff test %edi,%edi <== NOT EXECUTED 1293e5: 74 12 je 1293f9 <== NOT EXECUTED memfile_free_blocks_in_table( &info->indirect, to_free ); 1293e7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1293ea: 52 push %edx <== NOT EXECUTED 1293eb: 89 f0 mov %esi,%eax <== NOT EXECUTED 1293ed: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 1293f0: 50 push %eax <== NOT EXECUTED 1293f1: e8 3e ff ff ff call 129334 <== NOT EXECUTED 1293f6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if ( info->doubly_indirect ) { 1293f9: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1293fc: 8b 42 58 mov 0x58(%edx),%eax <== NOT EXECUTED 1293ff: 85 c0 test %eax,%eax <== NOT EXECUTED 129401: 74 5d je 129460 <== NOT EXECUTED for ( i=0 ; i <== NOT EXECUTED 129410: 31 db xor %ebx,%ebx <== NOT EXECUTED 129412: 31 d2 xor %edx,%edx <== NOT EXECUTED 129414: eb 08 jmp 12941e <== NOT EXECUTED 129416: 66 90 xchg %ax,%ax <== NOT EXECUTED 129418: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 12941b: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED if ( info->doubly_indirect[i] ) { 12941e: c1 e2 02 shl $0x2,%edx <== NOT EXECUTED 129421: 8b 34 10 mov (%eax,%edx,1),%esi <== NOT EXECUTED 129424: 85 f6 test %esi,%esi <== NOT EXECUTED 129426: 74 17 je 12943f <== NOT EXECUTED memfile_free_blocks_in_table( 129428: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12942b: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 12942e: 01 d0 add %edx,%eax <== NOT EXECUTED 129430: 50 push %eax <== NOT EXECUTED 129431: e8 fe fe ff ff call 129334 <== NOT EXECUTED 129436: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129439: 8b 0d b0 de 14 00 mov 0x14deb0,%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 ); 12944b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12944e: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 129451: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129454: 83 c0 58 add $0x58,%eax <== NOT EXECUTED 129457: 50 push %eax <== NOT EXECUTED 129458: e8 d7 fe ff ff call 129334 <== NOT EXECUTED 12945d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } if ( info->triply_indirect ) { 129460: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 129463: 8b 42 5c mov 0x5c(%edx),%eax <== NOT EXECUTED 129466: 85 c0 test %eax,%eax <== NOT EXECUTED 129468: 0f 84 b4 00 00 00 je 129522 <== NOT EXECUTED for ( i=0 ; i <== NOT EXECUTED p = (block_p *) info->triply_indirect[i]; 12947f: 8b 30 mov (%eax),%esi <== NOT EXECUTED if ( !p ) /* ensure we have a valid pointer */ 129481: 85 f6 test %esi,%esi <== NOT EXECUTED 129483: 0f 84 84 00 00 00 je 12950d <== NOT EXECUTED 129489: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED 129490: 31 ff xor %edi,%edi <== NOT EXECUTED 129492: 66 90 xchg %ax,%ax <== NOT EXECUTED break; for ( j=0 ; j <== NOT EXECUTED 12949b: 31 db xor %ebx,%ebx <== NOT EXECUTED 12949d: 31 d2 xor %edx,%edx <== NOT EXECUTED 12949f: 90 nop <== NOT EXECUTED if ( p[j] ) { 1294a0: 8d 04 95 00 00 00 00 lea 0x0(,%edx,4),%eax <== NOT EXECUTED 1294a7: 8b 14 06 mov (%esi,%eax,1),%edx <== NOT EXECUTED 1294aa: 85 d2 test %edx,%edx <== NOT EXECUTED 1294ac: 74 18 je 1294c6 <== NOT EXECUTED memfile_free_blocks_in_table( (block_p **)&p[j], to_free); 1294ae: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1294b1: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 1294b4: 8d 04 06 lea (%esi,%eax,1),%eax <== NOT EXECUTED 1294b7: 50 push %eax <== NOT EXECUTED 1294b8: e8 77 fe ff ff call 129334 <== NOT EXECUTED 1294bd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1294c0: 8b 0d b0 de 14 00 mov 0x14deb0,%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( 1294d2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1294d5: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 1294d8: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1294db: 03 7a 5c add 0x5c(%edx),%edi <== NOT EXECUTED 1294de: 57 push %edi <== NOT EXECUTED 1294df: e8 50 fe ff ff call 129334 <== 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 */ 1294fa: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 1294fd: c1 e7 02 shl $0x2,%edi <== NOT EXECUTED } if ( info->triply_indirect ) { for ( i=0 ; itriply_indirect[i]; 129500: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 129503: 8b 42 5c mov 0x5c(%edx),%eax <== NOT EXECUTED 129506: 8b 34 38 mov (%eax,%edi,1),%esi <== NOT EXECUTED if ( !p ) /* ensure we have a valid pointer */ 129509: 85 f6 test %esi,%esi <== NOT EXECUTED 12950b: 75 87 jne 129494 <== NOT EXECUTED } } memfile_free_blocks_in_table( (block_p **)&info->triply_indirect[i], to_free ); } memfile_free_blocks_in_table( 12950d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129510: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 129513: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129516: 83 c0 5c add $0x5c,%eax <== NOT EXECUTED 129519: 50 push %eax <== NOT EXECUTED 12951a: e8 15 fe ff ff call 129334 <== NOT EXECUTED 12951f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (block_p **)&info->triply_indirect, to_free ); } return 0; } 129522: 31 c0 xor %eax,%eax <== NOT EXECUTED 129524: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 129527: 5b pop %ebx <== NOT EXECUTED 129528: 5e pop %esi <== NOT EXECUTED 129529: 5f pop %edi <== NOT EXECUTED 12952a: c9 leave <== NOT EXECUTED 12952b: c3 ret <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 12952c: 68 6d 43 14 00 push $0x14436d <== NOT EXECUTED 129531: 68 94 44 14 00 push $0x144494 <== NOT EXECUTED 129536: 68 ec 01 00 00 push $0x1ec <== NOT EXECUTED 12953b: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 129540: e8 67 1a 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 ); 129545: 68 e0 43 14 00 push $0x1443e0 <== NOT EXECUTED 12954a: 68 94 44 14 00 push $0x144494 <== NOT EXECUTED 12954f: 68 f0 01 00 00 push $0x1f0 <== NOT EXECUTED 129554: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 129559: e8 4e 1a fe ff call 10afac <__assert_func> <== NOT EXECUTED 00129308 : MEMFILE_STATIC int IMFS_memfile_remove_block( IMFS_jnode_t *the_jnode, unsigned int block ) { 129308: 55 push %ebp <== NOT EXECUTED 129309: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12930b: 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 ); 12930e: 6a 00 push $0x0 <== NOT EXECUTED 129310: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 129313: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 129316: e8 09 fe ff ff call 129124 <== NOT EXECUTED ptr = *block_entry_ptr; 12931b: 8b 10 mov (%eax),%edx <== NOT EXECUTED *block_entry_ptr = 0; 12931d: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED memfile_free_block( ptr ); 129323: 89 14 24 mov %edx,(%esp) <== NOT EXECUTED 129326: e8 b9 fd ff ff call 1290e4 <== NOT EXECUTED return 1; } 12932b: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 129330: c9 leave <== NOT EXECUTED 129331: c3 ret <== NOT EXECUTED 00129858 : IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 129858: 55 push %ebp <== NOT EXECUTED 129859: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12985b: 57 push %edi <== NOT EXECUTED 12985c: 56 push %esi <== NOT EXECUTED 12985d: 53 push %ebx <== NOT EXECUTED 12985e: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 129861: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129864: 85 c0 test %eax,%eax <== NOT EXECUTED 129866: 0f 84 ce 01 00 00 je 129a3a <== NOT EXECUTED if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 12986c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 12986f: 83 78 4c 05 cmpl $0x5,0x4c(%eax) <== NOT EXECUTED 129873: 0f 85 a8 01 00 00 jne 129a21 <== NOT EXECUTED /* * Error check arguments */ assert( source ); 129879: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 12987c: 85 c0 test %eax,%eax <== NOT EXECUTED 12987e: 0f 84 cf 01 00 00 je 129a53 <== NOT EXECUTED /* * If there is nothing to write, then quick exit. */ my_length = length; if ( !my_length ) 129884: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 129887: 85 c0 test %eax,%eax <== NOT EXECUTED 129889: 0f 84 7b 01 00 00 je 129a0a <== 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; 12988f: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 129892: 03 45 0c add 0xc(%ebp),%eax <== NOT EXECUTED if ( last_byte > the_jnode->info.file.size ) { 129895: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 129898: 3b 42 50 cmp 0x50(%edx),%eax <== NOT EXECUTED 12989b: 0f 87 1f 01 00 00 ja 1299c0 <== NOT EXECUTED /* * Phase 1: possibly the last part of one block */ start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK; 1298a1: 8b 1d b0 de 14 00 mov 0x14deb0,%ebx <== NOT EXECUTED 1298a7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1298aa: 99 cltd <== NOT EXECUTED 1298ab: f7 fb idiv %ebx <== NOT EXECUTED 1298ad: 89 55 c0 mov %edx,-0x40(%ebp) <== NOT EXECUTED 1298b0: 89 45 bc mov %eax,-0x44(%ebp) <== NOT EXECUTED block = start / IMFS_MEMFILE_BYTES_PER_BLOCK; 1298b3: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED if ( start_offset ) { 1298b6: 85 d2 test %edx,%edx <== NOT EXECUTED 1298b8: 0f 85 ae 00 00 00 jne 12996c <== NOT EXECUTED 1298be: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 1298c1: 89 4d c0 mov %ecx,-0x40(%ebp) <== NOT EXECUTED 1298c4: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 1298c7: 89 75 e0 mov %esi,-0x20(%ebp) <== NOT EXECUTED 1298ca: 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 ) { 1298d1: 39 5d c0 cmp %ebx,-0x40(%ebp) <== NOT EXECUTED 1298d4: 72 3b jb 129911 <== NOT EXECUTED 1298d6: 66 90 xchg %ax,%ax <== NOT EXECUTED block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 1298d8: 57 push %edi <== NOT EXECUTED 1298d9: 6a 00 push $0x0 <== NOT EXECUTED 1298db: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 1298de: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1298e1: e8 3e f8 ff ff call 129124 <== NOT EXECUTED assert( block_ptr ); 1298e6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1298e9: 85 c0 test %eax,%eax <== NOT EXECUTED 1298eb: 0f 84 00 01 00 00 je 1299f1 <== 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 ); 1298f1: 8b 38 mov (%eax),%edi <== NOT EXECUTED src += to_copy; 1298f3: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 1298f6: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 1298f8: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1298fa: 89 75 e0 mov %esi,-0x20(%ebp) <== NOT EXECUTED block++; 1298fd: ff 45 d8 incl -0x28(%ebp) <== NOT EXECUTED my_length -= to_copy; 129900: 29 5d c0 sub %ebx,-0x40(%ebp) <== NOT EXECUTED IMFS_jnode_t *the_jnode, off_t start, const unsigned char *source, unsigned int length ) { 129903: 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 ) { 129906: 8b 7d c0 mov -0x40(%ebp),%edi <== NOT EXECUTED 129909: 39 3d b0 de 14 00 cmp %edi,0x14deb0 <== NOT EXECUTED 12990f: 76 c7 jbe 1298d8 <== NOT EXECUTED */ assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK ); to_copy = my_length; if ( my_length ) { 129911: 8b 75 c0 mov -0x40(%ebp),%esi <== NOT EXECUTED 129914: 85 f6 test %esi,%esi <== NOT EXECUTED 129916: 74 29 je 129941 <== NOT EXECUTED block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 ); 129918: 53 push %ebx <== NOT EXECUTED 129919: 6a 00 push $0x0 <== NOT EXECUTED 12991b: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 12991e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 129921: e8 fe f7 ff ff call 129124 <== NOT EXECUTED assert( block_ptr ); 129926: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129929: 85 c0 test %eax,%eax <== NOT EXECUTED 12992b: 0f 84 54 01 00 00 je 129a85 <== 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 ); 129931: 8b 38 mov (%eax),%edi <== NOT EXECUTED 129933: 8b 75 e0 mov -0x20(%ebp),%esi <== NOT EXECUTED 129936: 8b 4d c0 mov -0x40(%ebp),%ecx <== NOT EXECUTED 129939: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED my_length = 0; copied += to_copy; 12993b: 8b 7d c0 mov -0x40(%ebp),%edi <== NOT EXECUTED 12993e: 01 7d dc add %edi,-0x24(%ebp) <== NOT EXECUTED } IMFS_atime_mtime_update( the_jnode ); 129941: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129944: 6a 00 push $0x0 <== NOT EXECUTED 129946: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 129949: 50 push %eax <== NOT EXECUTED 12994a: e8 9d 1a fe ff call 10b3ec <== NOT EXECUTED 12994f: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 129952: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 129955: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED 129958: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED 12995b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return copied; } 12995e: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 129961: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 129964: 5b pop %ebx <== NOT EXECUTED 129965: 5e pop %esi <== NOT EXECUTED 129966: 5f pop %edi <== NOT EXECUTED 129967: c9 leave <== NOT EXECUTED 129968: c3 ret <== NOT EXECUTED 129969: 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 ); 12996c: 50 push %eax <== NOT EXECUTED 12996d: 6a 00 push $0x0 <== NOT EXECUTED 12996f: ff 75 bc pushl -0x44(%ebp) <== NOT EXECUTED 129972: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 129975: e8 aa f7 ff ff call 129124 <== NOT EXECUTED assert( block_ptr ); 12997a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12997d: 85 c0 test %eax,%eax <== NOT EXECUTED 12997f: 0f 84 e7 00 00 00 je 129a6c <== 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; 129985: 89 da mov %ebx,%edx <== NOT EXECUTED 129987: 2b 55 c0 sub -0x40(%ebp),%edx <== NOT EXECUTED 12998a: 3b 55 14 cmp 0x14(%ebp),%edx <== NOT EXECUTED 12998d: 77 5d ja 1299ec <== 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 ); 12998f: 8b 38 mov (%eax),%edi <== NOT EXECUTED 129991: 01 7d c0 add %edi,-0x40(%ebp) <== NOT EXECUTED src += to_copy; 129994: 8b 7d c0 mov -0x40(%ebp),%edi <== NOT EXECUTED 129997: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 12999a: 89 d1 mov %edx,%ecx <== NOT EXECUTED 12999c: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 12999e: 89 75 e0 mov %esi,-0x20(%ebp) <== NOT EXECUTED block++; 1299a1: 8b 45 bc mov -0x44(%ebp),%eax <== NOT EXECUTED 1299a4: 40 inc %eax <== NOT EXECUTED 1299a5: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED my_length -= to_copy; 1299a8: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 1299ab: 29 d1 sub %edx,%ecx <== NOT EXECUTED 1299ad: 89 4d c0 mov %ecx,-0x40(%ebp) <== NOT EXECUTED copied += to_copy; 1299b0: 89 55 dc mov %edx,-0x24(%ebp) <== NOT EXECUTED 1299b3: 8b 1d b0 de 14 00 mov 0x14deb0,%ebx <== NOT EXECUTED 1299b9: e9 13 ff ff ff jmp 1298d1 <== NOT EXECUTED 1299be: 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 ); 1299c0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1299c3: 50 push %eax <== NOT EXECUTED 1299c4: 52 push %edx <== NOT EXECUTED 1299c5: e8 de fc ff ff call 1296a8 <== NOT EXECUTED if ( status ) 1299ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1299cd: 85 c0 test %eax,%eax <== NOT EXECUTED 1299cf: 0f 84 cc fe ff ff je 1298a1 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); 1299d5: e8 06 74 00 00 call 130de0 <__errno> <== NOT EXECUTED 1299da: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 1299e0: c7 45 dc ff ff ff ff movl $0xffffffff,-0x24(%ebp) <== NOT EXECUTED 1299e7: e9 72 ff ff ff jmp 12995e <== 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; 1299ec: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 1299ef: eb 9e jmp 12998f <== 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 ); 1299f1: 68 83 43 14 00 push $0x144383 <== NOT EXECUTED 1299f6: 68 6f 44 14 00 push $0x14446f <== NOT EXECUTED 1299fb: 68 2e 03 00 00 push $0x32e <== NOT EXECUTED 129a00: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 129a05: e8 a2 15 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 ); 129a0a: e8 d1 73 00 00 call 130de0 <__errno> <== NOT EXECUTED 129a0f: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 129a15: c7 45 dc ff ff ff ff movl $0xffffffff,-0x24(%ebp) <== NOT EXECUTED 129a1c: e9 3d ff ff ff jmp 12995e <== NOT EXECUTED assert( the_jnode ); if ( !the_jnode ) rtems_set_errno_and_return_minus_one( EIO ); assert( the_jnode->type == IMFS_MEMORY_FILE ); 129a21: 68 e0 43 14 00 push $0x1443e0 <== NOT EXECUTED 129a26: 68 6f 44 14 00 push $0x14446f <== NOT EXECUTED 129a2b: 68 e5 02 00 00 push $0x2e5 <== NOT EXECUTED 129a30: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 129a35: e8 72 15 fe ff call 10afac <__assert_func> <== NOT EXECUTED /* * Perform internal consistency checks */ assert( the_jnode ); 129a3a: 68 6d 43 14 00 push $0x14436d <== NOT EXECUTED 129a3f: 68 6f 44 14 00 push $0x14446f <== NOT EXECUTED 129a44: 68 e1 02 00 00 push $0x2e1 <== NOT EXECUTED 129a49: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 129a4e: e8 59 15 fe ff call 10afac <__assert_func> <== NOT EXECUTED /* * Error check arguments */ assert( source ); 129a53: 68 8c 3e 14 00 push $0x143e8c <== NOT EXECUTED 129a58: 68 6f 44 14 00 push $0x14446f <== NOT EXECUTED 129a5d: 68 ed 02 00 00 push $0x2ed <== NOT EXECUTED 129a62: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 129a67: e8 40 15 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 ); 129a6c: 68 83 43 14 00 push $0x144383 <== NOT EXECUTED 129a71: 68 6f 44 14 00 push $0x14446f <== NOT EXECUTED 129a76: 68 1a 03 00 00 push $0x31a <== NOT EXECUTED 129a7b: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 129a80: e8 27 15 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 ); 129a85: 68 83 43 14 00 push $0x144383 <== NOT EXECUTED 129a8a: 68 6f 44 14 00 push $0x14446f <== NOT EXECUTED 129a8f: 68 44 03 00 00 push $0x344 <== NOT EXECUTED 129a94: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 129a99: e8 0e 15 fe ff call 10afac <__assert_func> <== NOT EXECUTED 0010e168 : const char *token, /* IN */ mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10e168: 55 push %ebp <== NOT EXECUTED 10e169: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e16b: 57 push %edi <== NOT EXECUTED 10e16c: 56 push %esi <== NOT EXECUTED 10e16d: 53 push %ebx <== NOT EXECUTED 10e16e: 83 ec 50 sub $0x50,%esp <== NOT EXECUTED 10e171: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10e174: 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 ); 10e177: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10e17a: 50 push %eax <== NOT EXECUTED 10e17b: 8d 7d bf lea -0x41(%ebp),%edi <== NOT EXECUTED 10e17e: 57 push %edi <== NOT EXECUTED 10e17f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10e182: e8 45 fe ff ff call 10dfcc <== NOT EXECUTED /* * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) 10e187: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e18a: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 10e18f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e192: 3d 00 40 00 00 cmp $0x4000,%eax <== NOT EXECUTED 10e197: 74 4f je 10e1e8 <== NOT EXECUTED type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) 10e199: 3d 00 80 00 00 cmp $0x8000,%eax <== NOT EXECUTED 10e19e: 74 40 je 10e1e0 <== NOT EXECUTED type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { 10e1a0: 3d 00 60 00 00 cmp $0x6000,%eax <== NOT EXECUTED 10e1a5: 74 07 je 10e1ae <== NOT EXECUTED 10e1a7: 3d 00 20 00 00 cmp $0x2000,%eax <== NOT EXECUTED 10e1ac: 75 42 jne 10e1f0 <== NOT EXECUTED type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); 10e1ae: 89 5d e0 mov %ebx,-0x20(%ebp) <== NOT EXECUTED 10e1b1: 89 75 e4 mov %esi,-0x1c(%ebp) <== NOT EXECUTED 10e1b4: ba 02 00 00 00 mov $0x2,%edx <== NOT EXECUTED /* * Allocate and fill in an IMFS jnode */ new_node = IMFS_create_node( 10e1b9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e1bc: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 10e1bf: 50 push %eax <== NOT EXECUTED 10e1c0: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10e1c3: 57 push %edi <== NOT EXECUTED 10e1c4: 52 push %edx <== NOT EXECUTED 10e1c5: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10e1c8: e8 8f 18 00 00 call 10fa5c <== NOT EXECUTED new_name, mode, &info ); if ( !new_node ) 10e1cd: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10e1d0: 85 c0 test %eax,%eax <== NOT EXECUTED 10e1d2: 74 2e je 10e202 <== NOT EXECUTED 10e1d4: 31 c0 xor %eax,%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOMEM ); return 0; } 10e1d6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e1d9: 5b pop %ebx <== NOT EXECUTED 10e1da: 5e pop %esi <== NOT EXECUTED 10e1db: 5f pop %edi <== NOT EXECUTED 10e1dc: c9 leave <== NOT EXECUTED 10e1dd: c3 ret <== NOT EXECUTED 10e1de: 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) ) 10e1e0: ba 05 00 00 00 mov $0x5,%edx <== NOT EXECUTED 10e1e5: eb d2 jmp 10e1b9 <== NOT EXECUTED 10e1e7: 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 ); 10e1e8: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10e1ed: eb ca jmp 10e1b9 <== NOT EXECUTED 10e1ef: 90 nop <== NOT EXECUTED 10e1f0: e8 c3 1f 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10e1f5: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10e1fb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e200: eb d4 jmp 10e1d6 <== NOT EXECUTED mode, &info ); if ( !new_node ) rtems_set_errno_and_return_minus_one( ENOMEM ); 10e202: e8 b1 1f 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10e207: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10e20d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e212: eb c2 jmp 10e1d6 <== 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 63 61 02 00 call 130de0 <__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 0010e214 : #include "imfs.h" rtems_filesystem_node_types_t IMFS_node_type( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 10e214: 55 push %ebp <== NOT EXECUTED 10e215: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e217: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e21a: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10e21c: 8b 40 4c mov 0x4c(%eax),%eax <== NOT EXECUTED IMFS_jnode_t *node; node = pathloc->node_access; return node->type; } 10e21f: c9 leave <== NOT EXECUTED 10e220: c3 ret <== 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 ed 60 02 00 call 130de0 <__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 0010e224 : */ int IMFS_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 10e224: 55 push %ebp <== NOT EXECUTED 10e225: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e227: 56 push %esi <== NOT EXECUTED 10e228: 53 push %ebx <== NOT EXECUTED 10e229: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10e22c: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 10e22f: 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 ) { 10e231: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10e234: 85 c0 test %eax,%eax <== NOT EXECUTED 10e236: 74 13 je 10e24b <== NOT EXECUTED 10e238: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e23b: 53 push %ebx <== NOT EXECUTED 10e23c: e8 9b 0d 00 00 call 10efdc <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 10e241: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED 10e248: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 10e24b: 66 ff 4b 34 decw 0x34(%ebx) <== NOT EXECUTED IMFS_update_ctime( the_jnode ); 10e24f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e252: 6a 00 push $0x0 <== NOT EXECUTED 10e254: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10e257: 50 push %eax <== NOT EXECUTED 10e258: e8 8f 03 00 00 call 10e5ec <== NOT EXECUTED 10e25d: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10e260: 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) ) { 10e263: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10e266: e8 39 04 00 00 call 10e6a4 <== NOT EXECUTED 10e26b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e26e: 85 c0 test %eax,%eax <== NOT EXECUTED 10e270: 75 26 jne 10e298 <== NOT EXECUTED 10e272: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) <== NOT EXECUTED 10e277: 75 1f jne 10e298 <== NOT EXECUTED /* * Is rtems_filesystem_current this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 10e279: 8b 15 54 c8 11 00 mov 0x11c854,%edx <== NOT EXECUTED 10e27f: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10e282: 3b 06 cmp (%esi),%eax <== NOT EXECUTED 10e284: 74 36 je 10e2bc <== NOT EXECUTED /* * Free memory associated with a memory file. */ if ( the_jnode->type == IMFS_SYM_LINK ) { 10e286: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx) <== NOT EXECUTED 10e28a: 74 18 je 10e2a4 <== NOT EXECUTED if ( the_jnode->info.sym_link.name ) free( (void*) the_jnode->info.sym_link.name ); } free( the_jnode ); 10e28c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e28f: 53 push %ebx <== NOT EXECUTED 10e290: e8 0b 8e ff ff call 1070a0 <== NOT EXECUTED 10e295: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 10e298: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e29a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e29d: 5b pop %ebx <== NOT EXECUTED 10e29e: 5e pop %esi <== NOT EXECUTED 10e29f: c9 leave <== NOT EXECUTED 10e2a0: c3 ret <== NOT EXECUTED 10e2a1: 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 ) 10e2a4: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10e2a7: 85 c0 test %eax,%eax <== NOT EXECUTED 10e2a9: 74 e1 je 10e28c <== NOT EXECUTED free( (void*) the_jnode->info.sym_link.name ); 10e2ab: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e2ae: 50 push %eax <== NOT EXECUTED 10e2af: e8 ec 8d ff ff call 1070a0 <== NOT EXECUTED 10e2b4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e2b7: eb d3 jmp 10e28c <== NOT EXECUTED 10e2b9: 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; 10e2bc: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10e2c3: eb c1 jmp 10e286 <== NOT EXECUTED 0010e2c8 : int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 10e2c8: 55 push %ebp <== NOT EXECUTED 10e2c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e2cb: 53 push %ebx <== NOT EXECUTED 10e2cc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10e2cf: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *the_jnode; IMFS_device_t *io; the_jnode = loc->node_access; 10e2d2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10e2d5: 8b 08 mov (%eax),%ecx <== NOT EXECUTED switch ( the_jnode->type ) { 10e2d7: 8b 41 4c mov 0x4c(%ecx),%eax <== NOT EXECUTED 10e2da: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10e2dd: 74 65 je 10e344 <== NOT EXECUTED 10e2df: 7f 1b jg 10e2fc <== NOT EXECUTED 10e2e1: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10e2e4: 74 6a je 10e350 <== NOT EXECUTED case IMFS_SYM_LINK: buf->st_size = 0; break; default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 10e2e6: e8 cd 1e 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10e2eb: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10e2f1: 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; } 10e2f6: 5a pop %edx <== NOT EXECUTED 10e2f7: 5b pop %ebx <== NOT EXECUTED 10e2f8: c9 leave <== NOT EXECUTED 10e2f9: c3 ret <== NOT EXECUTED 10e2fa: 66 90 xchg %ax,%ax <== NOT EXECUTED IMFS_device_t *io; the_jnode = loc->node_access; switch ( the_jnode->type ) { 10e2fc: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 10e2ff: 7f e5 jg 10e2e6 <== 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; 10e301: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 10e304: 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; 10e307: 8b 41 30 mov 0x30(%ecx),%eax <== NOT EXECUTED 10e30a: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED buf->st_nlink = the_jnode->st_nlink; 10e30d: 8b 41 34 mov 0x34(%ecx),%eax <== NOT EXECUTED 10e310: 66 89 43 10 mov %ax,0x10(%ebx) <== NOT EXECUTED buf->st_ino = the_jnode->st_ino; 10e314: 8b 41 38 mov 0x38(%ecx),%eax <== NOT EXECUTED 10e317: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED buf->st_uid = the_jnode->st_uid; 10e31a: 8b 41 3c mov 0x3c(%ecx),%eax <== NOT EXECUTED 10e31d: 66 89 43 12 mov %ax,0x12(%ebx) <== NOT EXECUTED buf->st_gid = the_jnode->st_gid; 10e321: 66 8b 41 3e mov 0x3e(%ecx),%ax <== NOT EXECUTED 10e325: 66 89 43 14 mov %ax,0x14(%ebx) <== NOT EXECUTED buf->st_atime = the_jnode->stat_atime; 10e329: 8b 41 40 mov 0x40(%ecx),%eax <== NOT EXECUTED 10e32c: 89 43 24 mov %eax,0x24(%ebx) <== NOT EXECUTED buf->st_mtime = the_jnode->stat_mtime; 10e32f: 8b 41 44 mov 0x44(%ecx),%eax <== NOT EXECUTED 10e332: 89 43 2c mov %eax,0x2c(%ebx) <== NOT EXECUTED buf->st_ctime = the_jnode->stat_ctime; 10e335: 8b 41 48 mov 0x48(%ecx),%eax <== NOT EXECUTED 10e338: 89 43 34 mov %eax,0x34(%ebx) <== NOT EXECUTED 10e33b: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 10e33d: 5a pop %edx <== NOT EXECUTED 10e33e: 5b pop %ebx <== NOT EXECUTED 10e33f: c9 leave <== NOT EXECUTED 10e340: c3 ret <== NOT EXECUTED 10e341: 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; 10e344: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED 10e34b: eb ba jmp 10e307 <== NOT EXECUTED 10e34d: 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 ); 10e350: 8b 51 54 mov 0x54(%ecx),%edx <== NOT EXECUTED 10e353: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 10e356: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10e358: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 10e35b: eb aa jmp 10e307 <== 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 d0 a5 02 00 call 1352f0 <== 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 c3 78 01 00 call 122604 <== 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 8c 60 02 00 call 130de0 <__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 6f 60 02 00 call 130de0 <__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 91 79 01 00 call 12274c <== 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 da 5f 02 00 call 130de0 <__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 8b 5f 02 00 call 130de0 <__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 79 5f 02 00 call 130de0 <__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 84 cd 11 00 mov 0x11cd84,%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 88 cd 11 00 mov 0x11cd88,%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 94 ea 11 00 mov 0x11ea94,%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 a0 e8 11 00 push $0x11e8a0 <== NOT EXECUTED 107281: e8 6e 40 00 00 call 10b2f4 <_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 00 e9 11 00 add %ebx,0x11e900 <== 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 89 37 00 00 call 10aa40 <== 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 98 de 14 00 mov 0x14de98,%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 55 0e 14 00 push $0x140e55 <== NOT EXECUTED 1096b4: ff 35 94 de 14 00 pushl 0x14de94 <== 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 70 0e 14 00 push $0x140e70 <== NOT EXECUTED 1096d9: ff 35 94 de 14 00 pushl 0x14de94 <== NOT EXECUTED 1096df: ff 15 98 de 14 00 call *0x14de98 <== 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 90 de 14 00 mov 0x14de90,%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 9b 0e 14 00 push $0x140e9b <== NOT EXECUTED 1096f9: ff 35 94 de 14 00 pushl 0x14de94 <== NOT EXECUTED 1096ff: ff 15 98 de 14 00 call *0x14de98 <== 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 8e 0e 14 00 push $0x140e8e <== NOT EXECUTED 109718: ff 35 94 de 14 00 pushl 0x14de94 <== NOT EXECUTED 10971e: ff 15 98 de 14 00 call *0x14de98 <== 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 74 10 16 00 mov 0x161074,%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 70 10 16 00 mov $0x161070,%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 62 0e 14 00 push $0x140e62 <== NOT EXECUTED 109758: ff 35 94 de 14 00 pushl 0x14de94 <== 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 90 de 14 00 mov 0x14de90,%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 60 10 16 00 0d movl $0xfeedf00d,0x161060 <== NOT EXECUTED 10995f: f0 ed fe <== NOT EXECUTED p[1] = 0x0BAD0D06; 109962: c7 05 64 10 16 00 06 movl $0xbad0d06,0x161064 <== NOT EXECUTED 109969: 0d ad 0b <== NOT EXECUTED p[2] = 0xDEADF00D; /* DEAD FOOD GOOD DOG */ 10996c: c7 05 68 10 16 00 0d movl $0xdeadf00d,0x161068 <== NOT EXECUTED 109973: f0 ad de <== NOT EXECUTED p[3] = 0x600D0D06; 109976: c7 05 6c 10 16 00 06 movl $0x600d0d06,0x16106c <== 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 28 12 16 00 mov 0x161228,%edi <== NOT EXECUTED 109986: 85 ff test %edi,%edi <== NOT EXECUTED 109988: 74 1d je 1099a7 <== NOT EXECUTED 10998a: a1 e8 11 16 00 mov 0x1611e8,%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 74 10 16 00 mov %edi,0x161074 <== 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 70 10 16 00 mov %ecx,0x161070 <== 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 90 de 14 00 01 movl $0x1,0x14de90 <== 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 04 0f 14 00 push $0x140f04 <== 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 44 0f 14 00 push $0x140f44 <== 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 a3 61 00 00 call 10f9e0 <== 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 74 0f 14 00 push $0x140f74 <== 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 0010ac68 <_API_Mutex_Allocate>: #include void _API_Mutex_Allocate( API_Mutex_Control **the_mutex ) { 10ac68: 55 push %ebp <== NOT EXECUTED 10ac69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac6b: 57 push %edi <== NOT EXECUTED 10ac6c: 56 push %esi <== NOT EXECUTED 10ac6d: 53 push %ebx <== NOT EXECUTED 10ac6e: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED CORE_mutex_Attributes attr = { CORE_MUTEX_NESTING_IS_ERROR, FALSE, CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT, 0 }; 10ac71: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10ac74: be c0 85 11 00 mov $0x1185c0,%esi <== NOT EXECUTED 10ac79: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10ac7e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED mutex = (API_Mutex_Control *) _Objects_Allocate( &_API_Mutex_Information ); 10ac80: 68 00 eb 11 00 push $0x11eb00 <== NOT EXECUTED 10ac85: e8 e6 08 00 00 call 10b570 <_Objects_Allocate> <== NOT EXECUTED 10ac8a: 89 c3 mov %eax,%ebx <== NOT EXECUTED _CORE_mutex_Initialize( &mutex->Mutex, &attr, CORE_MUTEX_UNLOCKED ); 10ac8c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ac8f: 6a 01 push $0x1 <== NOT EXECUTED 10ac91: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 10ac94: 50 push %eax <== NOT EXECUTED 10ac95: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10ac98: 50 push %eax <== NOT EXECUTED 10ac99: e8 22 02 00 00 call 10aec0 <_CORE_mutex_Initialize> <== NOT EXECUTED 10ac9e: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 10aca2: a1 1c eb 11 00 mov 0x11eb1c,%eax <== NOT EXECUTED 10aca7: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10acaa: 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; 10acb1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10acb4: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10acb6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10acb9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10acbc: 5b pop %ebx <== NOT EXECUTED 10acbd: 5e pop %esi <== NOT EXECUTED 10acbe: 5f pop %edi <== NOT EXECUTED 10acbf: c9 leave <== NOT EXECUTED 10acc0: c3 ret <== NOT EXECUTED 0010ace8 <_API_Mutex_Initialization>: #include void _API_Mutex_Initialization( uint32_t maximum_mutexes ) { 10ace8: 55 push %ebp <== NOT EXECUTED 10ace9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aceb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10acee: 6a 00 push $0x0 <== NOT EXECUTED 10acf0: 6a 00 push $0x0 <== NOT EXECUTED 10acf2: 6a 74 push $0x74 <== NOT EXECUTED 10acf4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10acf7: 6a 02 push $0x2 <== NOT EXECUTED 10acf9: 6a 01 push $0x1 <== NOT EXECUTED 10acfb: 68 00 eb 11 00 push $0x11eb00 <== NOT EXECUTED 10ad00: e8 c3 0d 00 00 call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10ad05: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , TRUE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ad08: c9 leave <== NOT EXECUTED 10ad09: c3 ret <== NOT EXECUTED 0010acc4 <_API_Mutex_Lock>: #include void _API_Mutex_Lock( API_Mutex_Control *the_mutex ) { 10acc4: 55 push %ebp <== NOT EXECUTED 10acc5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10acc7: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10acca: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10accd: 9c pushf <== NOT EXECUTED 10acce: fa cli <== NOT EXECUTED 10accf: 5a pop %edx <== NOT EXECUTED _CORE_mutex_Seize( 10acd0: 52 push %edx <== NOT EXECUTED 10acd1: 6a 00 push $0x0 <== NOT EXECUTED 10acd3: 6a 01 push $0x1 <== NOT EXECUTED 10acd5: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10acd8: 83 c0 10 add $0x10,%eax <== NOT EXECUTED 10acdb: 50 push %eax <== NOT EXECUTED 10acdc: e8 d7 02 00 00 call 10afb8 <_CORE_mutex_Seize> <== NOT EXECUTED 10ace1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED the_mutex->Object.id, TRUE, 0, level ); } 10ace4: c9 leave <== NOT EXECUTED 10ace5: c3 ret <== NOT EXECUTED 0010ad0c <_API_Mutex_Unlock>: #include void _API_Mutex_Unlock( API_Mutex_Control *the_mutex ) { 10ad0c: 55 push %ebp <== NOT EXECUTED 10ad0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad0f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ad12: 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 10ad15: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10ad1a: 40 inc %eax <== NOT EXECUTED 10ad1b: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED _Thread_Disable_dispatch(); _CORE_mutex_Surrender( 10ad20: 6a 00 push $0x0 <== NOT EXECUTED 10ad22: ff 72 08 pushl 0x8(%edx) <== NOT EXECUTED 10ad25: 83 c2 10 add $0x10,%edx <== NOT EXECUTED 10ad28: 52 push %edx <== NOT EXECUTED 10ad29: e8 26 03 00 00 call 10b054 <_CORE_mutex_Surrender> <== NOT EXECUTED &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 10ad2e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10ad31: c9 leave <== NOT EXECUTED _CORE_mutex_Surrender( &the_mutex->Mutex, the_mutex->Object.id, NULL ); _Thread_Enable_dispatch(); 10ad32: e9 71 15 00 00 jmp 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED 0010ac50 <_API_extensions_Add>: */ void _API_extensions_Add( API_extensions_Control *the_extension ) { 10ac50: 55 push %ebp <== NOT EXECUTED 10ac51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac53: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED _Chain_Append( &_API_extensions_List, &the_extension->Node ); 10ac56: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ac59: 68 58 ec 11 00 push $0x11ec58 <== NOT EXECUTED 10ac5e: e8 d5 00 00 00 call 10ad38 <_Chain_Append> <== NOT EXECUTED 10ac63: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10ac66: c9 leave <== NOT EXECUTED 10ac67: c3 ret <== NOT EXECUTED 0010ab90 <_API_extensions_Initialization>: * * _API_extensions_Initialization */ void _API_extensions_Initialization( void ) { 10ab90: 55 push %ebp <== NOT EXECUTED 10ab91: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ab93: c7 05 58 ec 11 00 5c movl $0x11ec5c,0x11ec58 <== NOT EXECUTED 10ab9a: ec 11 00 <== NOT EXECUTED 10ab9d: c7 05 5c ec 11 00 00 movl $0x0,0x11ec5c <== NOT EXECUTED 10aba4: 00 00 00 <== NOT EXECUTED 10aba7: c7 05 60 ec 11 00 58 movl $0x11ec58,0x11ec60 <== NOT EXECUTED 10abae: ec 11 00 <== NOT EXECUTED _Chain_Initialize_empty( &_API_extensions_List ); } 10abb1: c9 leave <== NOT EXECUTED 10abb2: c3 ret <== NOT EXECUTED 0010abe4 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 10abe4: 55 push %ebp <== NOT EXECUTED 10abe5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10abe7: 53 push %ebx <== NOT EXECUTED 10abe8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10abeb: 8b 1d 58 ec 11 00 mov 0x11ec58,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10abf1: 81 fb 5c ec 11 00 cmp $0x11ec5c,%ebx <== NOT EXECUTED 10abf7: 74 16 je 10ac0f <_API_extensions_Run_postdriver+0x2b> <== NOT EXECUTED 10abf9: 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 ) 10abfc: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10abff: 85 c0 test %eax,%eax <== NOT EXECUTED 10ac01: 74 02 je 10ac05 <_API_extensions_Run_postdriver+0x21> <== NOT EXECUTED (*the_extension->postdriver_hook)(); 10ac03: 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 ) { 10ac05: 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 ) ; 10ac07: 81 fb 5c ec 11 00 cmp $0x11ec5c,%ebx <== NOT EXECUTED 10ac0d: 75 ed jne 10abfc <_API_extensions_Run_postdriver+0x18> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) (*the_extension->postdriver_hook)(); } } 10ac0f: 5a pop %edx <== NOT EXECUTED 10ac10: 5b pop %ebx <== NOT EXECUTED 10ac11: c9 leave <== NOT EXECUTED 10ac12: c3 ret <== NOT EXECUTED 0010ac14 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 10ac14: 55 push %ebp <== NOT EXECUTED 10ac15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ac17: 53 push %ebx <== NOT EXECUTED 10ac18: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10ac1b: 8b 1d 58 ec 11 00 mov 0x11ec58,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10ac21: 81 fb 5c ec 11 00 cmp $0x11ec5c,%ebx <== NOT EXECUTED 10ac27: 74 22 je 10ac4b <_API_extensions_Run_postswitch+0x37> <== NOT EXECUTED 10ac29: 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 ) 10ac2c: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10ac2f: 85 c0 test %eax,%eax <== NOT EXECUTED 10ac31: 74 0e je 10ac41 <_API_extensions_Run_postswitch+0x2d> <== NOT EXECUTED (*the_extension->postswitch_hook)( _Thread_Executing ); 10ac33: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ac36: ff 35 bc ea 11 00 pushl 0x11eabc <== NOT EXECUTED 10ac3c: ff d0 call *%eax <== NOT EXECUTED 10ac3e: 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 ) { 10ac41: 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 ) ; 10ac43: 81 fb 5c ec 11 00 cmp $0x11ec5c,%ebx <== NOT EXECUTED 10ac49: 75 e1 jne 10ac2c <_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 ); } } 10ac4b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ac4e: c9 leave <== NOT EXECUTED 10ac4f: c3 ret <== NOT EXECUTED 0010abb4 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 10abb4: 55 push %ebp <== NOT EXECUTED 10abb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10abb7: 53 push %ebx <== NOT EXECUTED 10abb8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10abbb: 8b 1d 58 ec 11 00 mov 0x11ec58,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10abc1: 81 fb 5c ec 11 00 cmp $0x11ec5c,%ebx <== NOT EXECUTED 10abc7: 74 16 je 10abdf <_API_extensions_Run_predriver+0x2b> <== NOT EXECUTED 10abc9: 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 ) 10abcc: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10abcf: 85 c0 test %eax,%eax <== NOT EXECUTED 10abd1: 74 02 je 10abd5 <_API_extensions_Run_predriver+0x21> <== NOT EXECUTED (*the_extension->predriver_hook)(); 10abd3: 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 ) { 10abd5: 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 ) ; 10abd7: 81 fb 5c ec 11 00 cmp $0x11ec5c,%ebx <== NOT EXECUTED 10abdd: 75 ed jne 10abcc <_API_extensions_Run_predriver+0x18> <== NOT EXECUTED the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) (*the_extension->predriver_hook)(); } } 10abdf: 58 pop %eax <== NOT EXECUTED 10abe0: 5b pop %ebx <== NOT EXECUTED 10abe1: c9 leave <== NOT EXECUTED 10abe2: c3 ret <== NOT EXECUTED 0010ebb4 <_Barrier_Manager_initialization>: */ void _Barrier_Manager_initialization( uint32_t maximum_barriers ) { 10ebb4: 55 push %ebp <== NOT EXECUTED 10ebb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ebb7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ebba: 6a 04 push $0x4 <== NOT EXECUTED 10ebbc: 6a 00 push $0x0 <== NOT EXECUTED 10ebbe: 6a 60 push $0x60 <== NOT EXECUTED 10ebc0: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ebc3: 6a 0a push $0xa <== NOT EXECUTED 10ebc5: 6a 02 push $0x2 <== NOT EXECUTED 10ebc7: 68 c0 ed 11 00 push $0x11edc0 <== NOT EXECUTED 10ebcc: e8 f7 ce ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10ebd1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ebd4: c9 leave <== NOT EXECUTED 10ebd5: c3 ret <== NOT EXECUTED 0010fbf0 <_Barrier_Translate_core_barrier_return_code>: }; rtems_status_code _Barrier_Translate_core_barrier_return_code ( CORE_barrier_Status the_barrier_status ) { 10fbf0: 55 push %ebp <== NOT EXECUTED 10fbf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fbf3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fbf6: 8b 04 85 b8 f4 11 00 mov 0x11f4b8(,%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]; } 10fbfd: c9 leave <== NOT EXECUTED 10fbfe: c3 ret <== NOT EXECUTED 0010bc1c <_CORE_barrier_Initialize>: void _CORE_barrier_Initialize( CORE_barrier_Control *the_barrier, CORE_barrier_Attributes *the_barrier_attributes ) { 10bc1c: 55 push %ebp <== NOT EXECUTED 10bc1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc1f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bc22: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bc25: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED the_barrier->Attributes = *the_barrier_attributes; 10bc28: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10bc2a: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10bc2d: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED 10bc30: 89 4a 40 mov %ecx,0x40(%edx) <== NOT EXECUTED the_barrier->number_of_waiting_threads = 0; 10bc33: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) <== NOT EXECUTED _Thread_queue_Initialize( 10bc3a: 6a 03 push $0x3 <== NOT EXECUTED 10bc3c: 68 00 00 01 00 push $0x10000 <== NOT EXECUTED 10bc41: 6a 00 push $0x0 <== NOT EXECUTED 10bc43: 52 push %edx <== NOT EXECUTED 10bc44: e8 13 1d 00 00 call 10d95c <_Thread_queue_Initialize> <== NOT EXECUTED 10bc49: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &the_barrier->Wait_queue, THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_BARRIER, CORE_BARRIER_TIMEOUT ); } 10bc4c: c9 leave <== NOT EXECUTED 10bc4d: c3 ret <== NOT EXECUTED 0010bc50 <_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 ) { 10bc50: 55 push %ebp <== NOT EXECUTED 10bc51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc53: 56 push %esi <== NOT EXECUTED 10bc54: 53 push %ebx <== NOT EXECUTED 10bc55: 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)) ) { 10bc58: 31 db xor %ebx,%ebx <== NOT EXECUTED 10bc5a: eb 01 jmp 10bc5d <_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++; 10bc5c: 43 inc %ebx <== NOT EXECUTED { Thread_Control *the_thread; uint32_t count; count = 0; while ( (the_thread = _Thread_queue_Dequeue(&the_barrier->Wait_queue)) ) { 10bc5d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bc60: 56 push %esi <== NOT EXECUTED 10bc61: e8 46 19 00 00 call 10d5ac <_Thread_queue_Dequeue> <== NOT EXECUTED 10bc66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bc69: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc6b: 75 ef jne 10bc5c <_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; 10bc6d: c7 46 48 00 00 00 00 movl $0x0,0x48(%esi) <== NOT EXECUTED return count; } 10bc74: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bc76: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10bc79: 5b pop %ebx <== NOT EXECUTED 10bc7a: 5e pop %esi <== NOT EXECUTED 10bc7b: c9 leave <== NOT EXECUTED 10bc7c: c3 ret <== NOT EXECUTED 0010bc80 <_CORE_barrier_Wait>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 10bc80: 55 push %ebp <== NOT EXECUTED 10bc81: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc83: 57 push %edi <== NOT EXECUTED 10bc84: 56 push %esi <== NOT EXECUTED 10bc85: 53 push %ebx <== NOT EXECUTED 10bc86: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bc89: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bc8c: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10bc8f: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 10bc92: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10bc95: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 10bc98: 8b 0d bc 17 12 00 mov 0x1217bc,%ecx <== NOT EXECUTED executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; 10bc9e: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) <== NOT EXECUTED _ISR_Disable( level ); 10bca5: 9c pushf <== NOT EXECUTED 10bca6: fa cli <== NOT EXECUTED 10bca7: 5b pop %ebx <== NOT EXECUTED the_barrier->number_of_waiting_threads++; 10bca8: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED 10bcab: 40 inc %eax <== NOT EXECUTED 10bcac: 89 42 48 mov %eax,0x48(%edx) <== NOT EXECUTED if ( the_barrier->number_of_waiting_threads == 10bcaf: 3b 42 44 cmp 0x44(%edx),%eax <== NOT EXECUTED 10bcb2: 75 07 jne 10bcbb <_CORE_barrier_Wait+0x3b> <== NOT EXECUTED the_barrier->Attributes.maximum_count) { if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { 10bcb4: 8b 42 40 mov 0x40(%edx),%eax <== NOT EXECUTED 10bcb7: 85 c0 test %eax,%eax <== NOT EXECUTED 10bcb9: 74 29 je 10bce4 <_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 10bcbb: 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; 10bcc2: 89 51 44 mov %edx,0x44(%ecx) <== NOT EXECUTED executing->Wait.id = id; 10bcc5: 89 79 20 mov %edi,0x20(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10bcc8: 53 push %ebx <== NOT EXECUTED 10bcc9: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 10bcca: c7 45 10 38 da 10 00 movl $0x10da38,0x10(%ebp) <== NOT EXECUTED 10bcd1: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10bcd4: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10bcd7: 58 pop %eax <== NOT EXECUTED 10bcd8: 5b pop %ebx <== NOT EXECUTED 10bcd9: 5e pop %esi <== NOT EXECUTED 10bcda: 5f pop %edi <== NOT EXECUTED 10bcdb: 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 ); 10bcdc: e9 07 1a 00 00 jmp 10d6e8 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 10bce1: 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; 10bce4: c7 41 34 01 00 00 00 movl $0x1,0x34(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10bceb: 53 push %ebx <== NOT EXECUTED 10bcec: 9d popf <== NOT EXECUTED _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support ); 10bced: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10bcf0: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 10bcf3: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 10bcf6: 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 ); } 10bcf9: 5a pop %edx <== NOT EXECUTED 10bcfa: 5b pop %ebx <== NOT EXECUTED 10bcfb: 5e pop %esi <== NOT EXECUTED 10bcfc: 5f pop %edi <== NOT EXECUTED 10bcfd: 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 ); 10bcfe: e9 4d ff ff ff jmp 10bc50 <_CORE_barrier_Release> <== NOT EXECUTED 001154f8 <_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 ) { 1154f8: 55 push %ebp <== NOT EXECUTED 1154f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1154fb: 57 push %edi <== NOT EXECUTED 1154fc: 56 push %esi <== NOT EXECUTED 1154fd: 53 push %ebx <== NOT EXECUTED 1154fe: 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 ) { 115501: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 115504: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 115507: 39 50 4c cmp %edx,0x4c(%eax) <== NOT EXECUTED 11550a: 72 58 jb 115564 <_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 ) { 11550c: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 11550f: 8b 46 48 mov 0x48(%esi),%eax <== NOT EXECUTED 115512: 85 c0 test %eax,%eax <== NOT EXECUTED 115514: 75 3a jne 115550 <_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))) { 115516: 31 db xor %ebx,%ebx <== NOT EXECUTED 115518: eb 16 jmp 115530 <_CORE_message_queue_Broadcast+0x38> <== NOT EXECUTED 11551a: 66 90 xchg %ax,%ax <== NOT EXECUTED waitp = &the_thread->Wait; number_broadcasted += 1; 11551c: 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 11551d: 8b 78 2c mov 0x2c(%eax),%edi <== NOT EXECUTED 115520: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 115523: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 115526: 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; 115528: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 11552b: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 11552e: 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))) { 115530: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 115533: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 115536: e8 29 22 00 00 call 117764 <_Thread_queue_Dequeue> <== NOT EXECUTED 11553b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11553e: 85 c0 test %eax,%eax <== NOT EXECUTED 115540: 75 da jne 11551c <_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; 115542: 8b 75 1c mov 0x1c(%ebp),%esi <== NOT EXECUTED 115545: 89 1e mov %ebx,(%esi) <== NOT EXECUTED return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 115547: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11554a: 5b pop %ebx <== NOT EXECUTED 11554b: 5e pop %esi <== NOT EXECUTED 11554c: 5f pop %edi <== NOT EXECUTED 11554d: c9 leave <== NOT EXECUTED 11554e: c3 ret <== NOT EXECUTED 11554f: 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; 115550: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 115553: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 115559: 31 c0 xor %eax,%eax <== NOT EXECUTED #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 11555b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11555e: 5b pop %ebx <== NOT EXECUTED 11555f: 5e pop %esi <== NOT EXECUTED 115560: 5f pop %edi <== NOT EXECUTED 115561: c9 leave <== NOT EXECUTED 115562: c3 ret <== NOT EXECUTED 115563: 90 nop <== NOT EXECUTED { Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 115564: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 115569: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11556c: 5b pop %ebx <== NOT EXECUTED 11556d: 5e pop %esi <== NOT EXECUTED 11556e: 5f pop %edi <== NOT EXECUTED 11556f: c9 leave <== NOT EXECUTED 115570: c3 ret <== NOT EXECUTED 00115dec <_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 ) { 115dec: 55 push %ebp <== NOT EXECUTED 115ded: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115def: 53 push %ebx <== NOT EXECUTED 115df0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 115df3: 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( 115df6: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 115df9: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 115dfc: 53 push %ebx <== NOT EXECUTED 115dfd: e8 e6 b9 ff ff call 1117e8 <_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 ) 115e02: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115e05: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 115e08: 85 c0 test %eax,%eax <== NOT EXECUTED 115e0a: 74 0c je 115e18 <_CORE_message_queue_Close+0x2c> <== NOT EXECUTED (void) _CORE_message_queue_Flush_support( the_message_queue ); 115e0c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 115e0f: 53 push %ebx <== NOT EXECUTED 115e10: e8 13 00 00 00 call 115e28 <_CORE_message_queue_Flush_support> <== NOT EXECUTED 115e15: 83 c4 10 add $0x10,%esp <== NOT EXECUTED (void) _Workspace_Free( the_message_queue->message_buffers ); 115e18: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED 115e1b: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 115e1e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 115e21: 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 ); 115e22: e9 65 c4 ff ff jmp 11228c <_Workspace_Free> <== NOT EXECUTED 001155b0 <_CORE_message_queue_Flush>: */ uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue ) { 1155b0: 55 push %ebp <== NOT EXECUTED 1155b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1155b3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages != 0 ) 1155b6: 8b 50 48 mov 0x48(%eax),%edx <== NOT EXECUTED 1155b9: 85 d2 test %edx,%edx <== NOT EXECUTED 1155bb: 75 07 jne 1155c4 <_CORE_message_queue_Flush+0x14> <== NOT EXECUTED return _CORE_message_queue_Flush_support( the_message_queue ); else return 0; } 1155bd: 31 c0 xor %eax,%eax <== NOT EXECUTED 1155bf: c9 leave <== NOT EXECUTED 1155c0: c3 ret <== NOT EXECUTED 1155c1: 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 ); 1155c4: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED else return 0; } 1155c7: 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 ); 1155c8: e9 03 00 00 00 jmp 1155d0 <_CORE_message_queue_Flush_support> <== NOT EXECUTED 00115e28 <_CORE_message_queue_Flush_support>: */ uint32_t _CORE_message_queue_Flush_support( CORE_message_queue_Control *the_message_queue ) { 115e28: 55 push %ebp <== NOT EXECUTED 115e29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115e2b: 56 push %esi <== NOT EXECUTED 115e2c: 53 push %ebx <== NOT EXECUTED 115e2d: 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 ); 115e30: 9c pushf <== NOT EXECUTED 115e31: fa cli <== NOT EXECUTED 115e32: 5e pop %esi <== NOT EXECUTED inactive_first = the_message_queue->Inactive_messages.first; 115e33: 8b 4a 68 mov 0x68(%edx),%ecx <== NOT EXECUTED message_queue_first = the_message_queue->Pending_messages.first; 115e36: 8b 5a 50 mov 0x50(%edx),%ebx <== NOT EXECUTED message_queue_last = the_message_queue->Pending_messages.last; 115e39: 8b 42 58 mov 0x58(%edx),%eax <== NOT EXECUTED the_message_queue->Inactive_messages.first = message_queue_first; 115e3c: 89 5a 68 mov %ebx,0x68(%edx) <== NOT EXECUTED message_queue_last->next = inactive_first; 115e3f: 89 08 mov %ecx,(%eax) <== NOT EXECUTED inactive_first->previous = message_queue_last; 115e41: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED message_queue_first->previous = 115e44: 8d 42 68 lea 0x68(%edx),%eax <== NOT EXECUTED 115e47: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED 115e4a: 8d 42 54 lea 0x54(%edx),%eax <== NOT EXECUTED 115e4d: 89 42 50 mov %eax,0x50(%edx) <== NOT EXECUTED 115e50: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) <== NOT EXECUTED 115e57: 8d 42 50 lea 0x50(%edx),%eax <== NOT EXECUTED 115e5a: 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; 115e5d: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED the_message_queue->number_of_pending_messages = 0; 115e60: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx) <== NOT EXECUTED _ISR_Enable( level ); 115e67: 56 push %esi <== NOT EXECUTED 115e68: 9d popf <== NOT EXECUTED return count; } 115e69: 5b pop %ebx <== NOT EXECUTED 115e6a: 5e pop %esi <== NOT EXECUTED 115e6b: c9 leave <== NOT EXECUTED 115e6c: c3 ret <== NOT EXECUTED 0010fdc0 <_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 ) { 10fdc0: 55 push %ebp <== NOT EXECUTED 10fdc1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fdc3: 57 push %edi <== NOT EXECUTED 10fdc4: 56 push %esi <== NOT EXECUTED 10fdc5: 53 push %ebx <== NOT EXECUTED 10fdc6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fdc9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10fdcc: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10fdcf: 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; 10fdd2: 89 7b 44 mov %edi,0x44(%ebx) <== NOT EXECUTED the_message_queue->number_of_pending_messages = 0; 10fdd5: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) <== NOT EXECUTED the_message_queue->maximum_message_size = maximum_message_size; 10fddc: 89 53 4c mov %edx,0x4c(%ebx) <== NOT EXECUTED 10fddf: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) <== NOT EXECUTED 10fde6: 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)) { 10fded: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10fdf0: 75 1a jne 10fe0c <_CORE_message_queue_Initialize+0x4c> <== NOT EXECUTED 10fdf2: 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 * 10fdf4: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 10fdf7: 89 f2 mov %esi,%edx <== NOT EXECUTED 10fdf9: 0f af d7 imul %edi,%edx <== NOT EXECUTED (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 10fdfc: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10fdfe: 73 18 jae 10fe18 <_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; 10fe00: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10fe02: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fe05: 5b pop %ebx <== NOT EXECUTED 10fe06: 5e pop %esi <== NOT EXECUTED 10fe07: 5f pop %edi <== NOT EXECUTED 10fe08: c9 leave <== NOT EXECUTED 10fe09: c3 ret <== NOT EXECUTED 10fe0a: 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); 10fe0c: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED allocated_message_size &= ~(sizeof(uint32_t) - 1); 10fe0f: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED } if (allocated_message_size < maximum_message_size) 10fe12: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10fe14: 77 ea ja 10fe00 <_CORE_message_queue_Initialize+0x40> <== NOT EXECUTED 10fe16: eb dc jmp 10fdf4 <_CORE_message_queue_Initialize+0x34> <== NOT EXECUTED return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 10fe18: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fe1b: 52 push %edx <== NOT EXECUTED 10fe1c: e8 e7 29 00 00 call 112808 <_Workspace_Allocate> <== NOT EXECUTED 10fe21: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 10fe24: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fe27: 85 c0 test %eax,%eax <== NOT EXECUTED 10fe29: 74 d5 je 10fe00 <_CORE_message_queue_Initialize+0x40> <== NOT EXECUTED /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 10fe2b: 56 push %esi <== NOT EXECUTED 10fe2c: 57 push %edi <== NOT EXECUTED 10fe2d: 50 push %eax <== NOT EXECUTED 10fe2e: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 10fe31: 50 push %eax <== NOT EXECUTED 10fe32: e8 3d 66 01 00 call 126474 <_Chain_Initialize> <== NOT EXECUTED 10fe37: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 10fe3a: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED 10fe3d: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED 10fe44: 8d 43 50 lea 0x50(%ebx),%eax <== NOT EXECUTED 10fe47: 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( 10fe4a: 6a 06 push $0x6 <== NOT EXECUTED 10fe4c: 68 80 00 00 00 push $0x80 <== NOT EXECUTED 10fe51: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10fe54: 83 38 01 cmpl $0x1,(%eax) <== NOT EXECUTED 10fe57: 0f 94 c0 sete %al <== NOT EXECUTED 10fe5a: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10fe5d: 50 push %eax <== NOT EXECUTED 10fe5e: 53 push %ebx <== NOT EXECUTED 10fe5f: e8 a4 1f 00 00 call 111e08 <_Thread_queue_Initialize> <== NOT EXECUTED 10fe64: b0 01 mov $0x1,%al <== NOT EXECUTED 10fe66: 83 c4 20 add $0x20,%esp <== NOT EXECUTED STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; } 10fe69: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fe6c: 5b pop %ebx <== NOT EXECUTED 10fe6d: 5e pop %esi <== NOT EXECUTED 10fe6e: 5f pop %edi <== NOT EXECUTED 10fe6f: c9 leave <== NOT EXECUTED 10fe70: c3 ret <== NOT EXECUTED 0010f040 <_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 ) { 10f040: 55 push %ebp <== NOT EXECUTED 10f041: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f043: 57 push %edi <== NOT EXECUTED 10f044: 56 push %esi <== NOT EXECUTED 10f045: 53 push %ebx <== NOT EXECUTED 10f046: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10f049: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10f04c: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10f04f: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED ISR_Level level; bool notify = false; the_message->priority = submit_type; 10f052: 89 47 08 mov %eax,0x8(%edi) <== NOT EXECUTED switch ( submit_type ) { 10f055: 3d 00 00 00 80 cmp $0x80000000,%eax <== NOT EXECUTED 10f05a: 0f 84 94 00 00 00 je 10f0f4 <_CORE_message_queue_Insert_message+0xb4> <== NOT EXECUTED 10f060: 3d ff ff ff 7f cmp $0x7fffffff,%eax <== NOT EXECUTED 10f065: 74 65 je 10f0cc <_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; 10f067: 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 10f06a: 8d 56 54 lea 0x54(%esi),%edx <== NOT EXECUTED while ( !_Chain_Is_tail( the_header, the_node ) ) { 10f06d: 39 da cmp %ebx,%edx <== NOT EXECUTED 10f06f: 75 49 jne 10f0ba <_CORE_message_queue_Insert_message+0x7a> <== NOT EXECUTED 10f071: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10f074: 89 d3 mov %edx,%ebx <== NOT EXECUTED continue; } break; } _ISR_Disable( level ); 10f076: 9c pushf <== NOT EXECUTED 10f077: fa cli <== NOT EXECUTED 10f078: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10f079: 8b 56 48 mov 0x48(%esi),%edx <== NOT EXECUTED 10f07c: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10f07f: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 10f082: 85 d2 test %edx,%edx <== NOT EXECUTED 10f084: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED notify = true; _Chain_Insert_unprotected( the_node->previous, &the_message->Node ); 10f088: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10f08b: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED 10f08e: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10f090: 89 38 mov %edi,(%eax) <== NOT EXECUTED 10f092: 89 17 mov %edx,(%edi) <== NOT EXECUTED 10f094: 89 7a 04 mov %edi,0x4(%edx) <== NOT EXECUTED _ISR_Enable( level ); 10f097: 51 push %ecx <== NOT EXECUTED 10f098: 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 ) 10f099: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10f09d: 74 25 je 10f0c4 <_CORE_message_queue_Insert_message+0x84> <== NOT EXECUTED 10f09f: 8b 4e 60 mov 0x60(%esi),%ecx <== NOT EXECUTED 10f0a2: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10f0a4: 74 1e je 10f0c4 <_CORE_message_queue_Insert_message+0x84> <== NOT EXECUTED (*the_message_queue->notify_handler)( the_message_queue->notify_argument ); 10f0a6: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED 10f0a9: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10f0ac: 5a pop %edx <== NOT EXECUTED 10f0ad: 5b pop %ebx <== NOT EXECUTED 10f0ae: 5e pop %esi <== NOT EXECUTED 10f0af: 5f pop %edi <== NOT EXECUTED 10f0b0: 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 ); 10f0b1: ff e1 jmp *%ecx <== NOT EXECUTED 10f0b3: 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; 10f0b4: 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 ) ) { 10f0b6: 39 da cmp %ebx,%edx <== NOT EXECUTED 10f0b8: 74 ba je 10f074 <_CORE_message_queue_Insert_message+0x34> <== NOT EXECUTED this_message = (CORE_message_queue_Buffer_control *) the_node; if ( this_message->priority <= the_message->priority ) { 10f0ba: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10f0bd: 7d f5 jge 10f0b4 <_CORE_message_queue_Insert_message+0x74> <== NOT EXECUTED 10f0bf: eb b5 jmp 10f076 <_CORE_message_queue_Insert_message+0x36> <== NOT EXECUTED 10f0c1: 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 ); } 10f0c4: 58 pop %eax <== NOT EXECUTED 10f0c5: 5b pop %ebx <== NOT EXECUTED 10f0c6: 5e pop %esi <== NOT EXECUTED 10f0c7: 5f pop %edi <== NOT EXECUTED 10f0c8: c9 leave <== NOT EXECUTED 10f0c9: c3 ret <== NOT EXECUTED 10f0ca: 66 90 xchg %ax,%ax <== NOT EXECUTED the_message->priority = submit_type; switch ( submit_type ) { case CORE_MESSAGE_QUEUE_SEND_REQUEST: _ISR_Disable( level ); 10f0cc: 9c pushf <== NOT EXECUTED 10f0cd: fa cli <== NOT EXECUTED 10f0ce: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10f0cf: 8b 56 48 mov 0x48(%esi),%edx <== NOT EXECUTED 10f0d2: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10f0d5: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 10f0d8: 85 d2 test %edx,%edx <== NOT EXECUTED 10f0da: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED 10f0de: 8d 46 54 lea 0x54(%esi),%eax <== NOT EXECUTED 10f0e1: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10f0e3: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED 10f0e6: 89 7e 58 mov %edi,0x58(%esi) <== NOT EXECUTED 10f0e9: 89 38 mov %edi,(%eax) <== NOT EXECUTED 10f0eb: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED notify = true; _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 10f0ee: 51 push %ecx <== NOT EXECUTED 10f0ef: 9d popf <== NOT EXECUTED 10f0f0: eb a7 jmp 10f099 <_CORE_message_queue_Insert_message+0x59> <== NOT EXECUTED 10f0f2: 66 90 xchg %ax,%ax <== NOT EXECUTED break; case CORE_MESSAGE_QUEUE_URGENT_REQUEST: _ISR_Disable( level ); 10f0f4: 9c pushf <== NOT EXECUTED 10f0f5: fa cli <== NOT EXECUTED 10f0f6: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10f0f7: 8b 56 48 mov 0x48(%esi),%edx <== NOT EXECUTED 10f0fa: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10f0fd: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 10f100: 85 d2 test %edx,%edx <== NOT EXECUTED 10f102: 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 10f106: 8d 46 50 lea 0x50(%esi),%eax <== NOT EXECUTED 10f109: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED 10f10c: 8b 46 50 mov 0x50(%esi),%eax <== NOT EXECUTED 10f10f: 89 7e 50 mov %edi,0x50(%esi) <== NOT EXECUTED 10f112: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10f114: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED notify = true; _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 10f117: 51 push %ecx <== NOT EXECUTED 10f118: 9d popf <== NOT EXECUTED 10f119: e9 7b ff ff ff jmp 10f099 <_CORE_message_queue_Insert_message+0x59> <== NOT EXECUTED 00115f50 <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 115f50: 55 push %ebp <== NOT EXECUTED 115f51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 115f53: 57 push %edi <== NOT EXECUTED 115f54: 56 push %esi <== NOT EXECUTED 115f55: 53 push %ebx <== NOT EXECUTED 115f56: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 115f59: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 115f5c: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 115f5f: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 115f62: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 115f65: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 115f68: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 115f6b: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 115f6e: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED 115f71: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 115f74: 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; 115f77: 8b 15 9c ca 12 00 mov 0x12ca9c,%edx <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 115f7d: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) <== NOT EXECUTED _ISR_Disable( level ); 115f84: 9c pushf <== NOT EXECUTED 115f85: fa cli <== NOT EXECUTED 115f86: 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( 115f87: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 115f8a: 8b 58 50 mov 0x50(%eax),%ebx <== NOT EXECUTED 115f8d: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 115f90: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 115f92: 74 7c je 116010 <_CORE_message_queue_Seize+0xc0> <== NOT EXECUTED 115f94: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 115f96: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 115f99: 89 57 50 mov %edx,0x50(%edi) <== NOT EXECUTED 115f9c: 89 f8 mov %edi,%eax <== NOT EXECUTED 115f9e: 83 c0 50 add $0x50,%eax <== NOT EXECUTED 115fa1: 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; 115fa4: ff 4f 48 decl 0x48(%edi) <== NOT EXECUTED _ISR_Enable( level ); 115fa7: 56 push %esi <== NOT EXECUTED 115fa8: 9d popf <== NOT EXECUTED *size_p = the_message->Contents.size; 115fa9: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 115fac: 89 01 mov %eax,(%ecx) <== NOT EXECUTED _Thread_Executing->Wait.count = the_message->priority; 115fae: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 115fb1: a1 9c ca 12 00 mov 0x12ca9c,%eax <== NOT EXECUTED 115fb6: 89 50 24 mov %edx,0x24(%eax) <== NOT EXECUTED _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p); 115fb9: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 115fbc: 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 115fbf: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED 115fc1: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 115fc4: 89 c6 mov %eax,%esi <== NOT EXECUTED 115fc6: 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 ); 115fc8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 115fcb: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 115fce: e8 91 b4 ff ff call 111464 <_Thread_queue_Dequeue> <== NOT EXECUTED 115fd3: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !the_thread ) { 115fd5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115fd8: 85 c0 test %eax,%eax <== NOT EXECUTED 115fda: 0f 84 84 00 00 00 je 116064 <_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; 115fe0: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED 115fe3: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED the_message->Contents.size = (size_t) the_thread->Wait.option; 115fe6: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED 115fe9: 89 4b 0c mov %ecx,0xc(%ebx) <== NOT EXECUTED 115fec: 8b 72 2c mov 0x2c(%edx),%esi <== NOT EXECUTED 115fef: 8b 7d d8 mov -0x28(%ebp),%edi <== NOT EXECUTED 115ff2: 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( 115ff4: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 115ff7: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 115ffa: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 115ffd: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 116000: 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 ); } 116003: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116006: 5b pop %ebx <== NOT EXECUTED 116007: 5e pop %esi <== NOT EXECUTED 116008: 5f pop %edi <== NOT EXECUTED 116009: 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( 11600a: e9 61 fe ff ff jmp 115e70 <_CORE_message_queue_Insert_message> <== NOT EXECUTED 11600f: 90 nop <== NOT EXECUTED the_message->priority ); return; } if ( !wait ) { 116010: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) <== NOT EXECUTED 116014: 75 12 jne 116028 <_CORE_message_queue_Seize+0xd8> <== NOT EXECUTED _ISR_Enable( level ); 116016: 56 push %esi <== NOT EXECUTED 116017: 9d popf <== NOT EXECUTED executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 116018: 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 ); } 11601f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116022: 5b pop %ebx <== NOT EXECUTED 116023: 5e pop %esi <== NOT EXECUTED 116024: 5f pop %edi <== NOT EXECUTED 116025: c9 leave <== NOT EXECUTED 116026: c3 ret <== NOT EXECUTED 116027: 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 116028: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11602b: 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; 116032: 89 42 44 mov %eax,0x44(%edx) <== NOT EXECUTED executing->Wait.id = id; 116035: 89 7a 20 mov %edi,0x20(%edx) <== NOT EXECUTED executing->Wait.return_argument_second.mutable_object = buffer; 116038: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 11603b: 89 7a 2c mov %edi,0x2c(%edx) <== NOT EXECUTED executing->Wait.return_argument = size_p; 11603e: 89 4a 28 mov %ecx,0x28(%edx) <== NOT EXECUTED /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 116041: 56 push %esi <== NOT EXECUTED 116042: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 116043: c7 45 10 f0 18 11 00 movl $0x1118f0,0x10(%ebp) <== NOT EXECUTED 11604a: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 11604d: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 116050: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 116053: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED } 116056: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116059: 5b pop %ebx <== NOT EXECUTED 11605a: 5e pop %esi <== NOT EXECUTED 11605b: 5f pop %edi <== NOT EXECUTED 11605c: 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 ); 11605d: e9 3e b5 ff ff jmp 1115a0 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 116062: 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 116064: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 116067: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 11606a: 83 c0 68 add $0x68,%eax <== NOT EXECUTED 11606d: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 116070: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116073: 5b pop %ebx <== NOT EXECUTED 116074: 5e pop %esi <== NOT EXECUTED 116075: 5f pop %edi <== NOT EXECUTED 116076: c9 leave <== NOT EXECUTED 116077: e9 c8 9a ff ff jmp 10fb44 <_Chain_Append> <== NOT EXECUTED 0010ad84 <_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 ) { 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 1c sub $0x1c,%esp <== NOT EXECUTED 10ad8d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10ad90: 8a 45 20 mov 0x20(%ebp),%al <== NOT EXECUTED 10ad93: 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 ) { 10ad96: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10ad99: 39 53 4c cmp %edx,0x4c(%ebx) <== NOT EXECUTED 10ad9c: 72 6e jb 10ae0c <_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 ) { 10ad9e: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10ada1: 85 c0 test %eax,%eax <== NOT EXECUTED 10ada3: 74 77 je 10ae1c <_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 < 10ada5: 39 43 44 cmp %eax,0x44(%ebx) <== NOT EXECUTED 10ada8: 0f 87 be 00 00 00 ja 10ae6c <_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 ) { 10adae: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10adb2: 0f 84 9c 00 00 00 je 10ae54 <_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() ) { 10adb8: a1 98 ea 11 00 mov 0x11ea98,%eax <== NOT EXECUTED 10adbd: 85 c0 test %eax,%eax <== NOT EXECUTED 10adbf: 0f 85 97 00 00 00 jne 10ae5c <_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; 10adc5: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED _ISR_Disable( level ); 10adca: 9c pushf <== NOT EXECUTED 10adcb: fa cli <== NOT EXECUTED 10adcc: 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 10adcd: 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; 10add4: 89 58 44 mov %ebx,0x44(%eax) <== NOT EXECUTED executing->Wait.id = id; 10add7: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 10adda: 89 70 20 mov %esi,0x20(%eax) <== NOT EXECUTED executing->Wait.return_argument_second.immutable_object = buffer; 10addd: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10ade0: 89 48 2c mov %ecx,0x2c(%eax) <== NOT EXECUTED executing->Wait.option = (uint32_t) size; 10ade3: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10ade6: 89 70 30 mov %esi,0x30(%eax) <== NOT EXECUTED executing->Wait.count = submit_type; 10ade9: 8b 4d 1c mov 0x1c(%ebp),%ecx <== NOT EXECUTED 10adec: 89 48 24 mov %ecx,0x24(%eax) <== NOT EXECUTED _ISR_Enable( level ); 10adef: 52 push %edx <== NOT EXECUTED 10adf0: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 10adf1: 50 push %eax <== NOT EXECUTED 10adf2: 68 b8 ca 10 00 push $0x10cab8 <== NOT EXECUTED 10adf7: ff 75 24 pushl 0x24(%ebp) <== NOT EXECUTED 10adfa: 53 push %ebx <== NOT EXECUTED 10adfb: e8 68 19 00 00 call 10c768 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED 10ae00: b8 07 00 00 00 mov $0x7,%eax <== NOT EXECUTED 10ae05: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae08: eb 07 jmp 10ae11 <_CORE_message_queue_Submit+0x8d> <== NOT EXECUTED 10ae0a: 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 ) { 10ae0c: 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; } 10ae11: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ae14: 5b pop %ebx <== NOT EXECUTED 10ae15: 5e pop %esi <== NOT EXECUTED 10ae16: 5f pop %edi <== NOT EXECUTED 10ae17: c9 leave <== NOT EXECUTED 10ae18: c3 ret <== NOT EXECUTED 10ae19: 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 ); 10ae1c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae1f: 53 push %ebx <== NOT EXECUTED 10ae20: e8 07 18 00 00 call 10c62c <_Thread_queue_Dequeue> <== NOT EXECUTED 10ae25: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( the_thread ) { 10ae27: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae2a: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae2c: 74 7e je 10aeac <_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 10ae2e: 8b 78 2c mov 0x2c(%eax),%edi <== NOT EXECUTED 10ae31: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10ae34: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10ae37: 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; 10ae39: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 10ae3c: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10ae3f: 89 08 mov %ecx,(%eax) <== NOT EXECUTED the_thread->Wait.count = submit_type; 10ae41: 8b 75 1c mov 0x1c(%ebp),%esi <== NOT EXECUTED 10ae44: 89 72 24 mov %esi,0x24(%edx) <== NOT EXECUTED 10ae47: 31 c0 xor %eax,%eax <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; } 10ae49: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ae4c: 5b pop %ebx <== NOT EXECUTED 10ae4d: 5e pop %esi <== NOT EXECUTED 10ae4e: 5f pop %edi <== NOT EXECUTED 10ae4f: c9 leave <== NOT EXECUTED 10ae50: c3 ret <== NOT EXECUTED 10ae51: 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 ) { 10ae54: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10ae59: eb b6 jmp 10ae11 <_CORE_message_queue_Submit+0x8d> <== NOT EXECUTED 10ae5b: 90 nop <== NOT EXECUTED _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; 10ae5c: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 10ae61: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ae64: 5b pop %ebx <== NOT EXECUTED 10ae65: 5e pop %esi <== NOT EXECUTED 10ae66: 5f pop %edi <== NOT EXECUTED 10ae67: c9 leave <== NOT EXECUTED 10ae68: c3 ret <== NOT EXECUTED 10ae69: 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. 10ae6c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ae6f: 8d 43 68 lea 0x68(%ebx),%eax <== NOT EXECUTED 10ae72: 50 push %eax <== NOT EXECUTED 10ae73: e8 e4 fe ff ff call 10ad5c <_Chain_Get> <== NOT EXECUTED /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 10ae78: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae7b: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae7d: 74 dd je 10ae5c <_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 10ae7f: 8d 78 10 lea 0x10(%eax),%edi <== NOT EXECUTED 10ae82: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10ae85: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10ae88: 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; 10ae8a: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10ae8d: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED the_message->priority = submit_type; 10ae90: 8b 4d 1c mov 0x1c(%ebp),%ecx <== NOT EXECUTED 10ae93: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED _CORE_message_queue_Insert_message( 10ae96: 52 push %edx <== NOT EXECUTED 10ae97: 51 push %ecx <== NOT EXECUTED 10ae98: 50 push %eax <== NOT EXECUTED 10ae99: 53 push %ebx <== NOT EXECUTED 10ae9a: e8 a1 41 00 00 call 10f040 <_CORE_message_queue_Insert_message> <== NOT EXECUTED 10ae9f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aea1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aea4: e9 68 ff ff ff jmp 10ae11 <_CORE_message_queue_Submit+0x8d> <== NOT EXECUTED 10aea9: 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 ) { 10aeac: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10aeaf: e9 f1 fe ff ff jmp 10ada5 <_CORE_message_queue_Submit+0x21> <== NOT EXECUTED 0010aeb4 <_CORE_mutex_Flush>: void _CORE_mutex_Flush( CORE_mutex_Control *the_mutex, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 10aeb4: 55 push %ebp <== NOT EXECUTED 10aeb5: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Thread_queue_Flush( &the_mutex->Wait_queue, remote_extract_callout, status ); } 10aeb7: c9 leave <== NOT EXECUTED CORE_mutex_Control *the_mutex, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { _Thread_queue_Flush( 10aeb8: e9 f3 1a 00 00 jmp 10c9b0 <_Thread_queue_Flush> <== NOT EXECUTED 0010aec0 <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 10aec0: 55 push %ebp <== NOT EXECUTED 10aec1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aec3: 57 push %edi <== NOT EXECUTED 10aec4: 56 push %esi <== NOT EXECUTED 10aec5: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10aec8: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10aecb: 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; 10aece: 8d 7a 40 lea 0x40(%edx),%edi <== NOT EXECUTED 10aed1: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10aed6: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10aed9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED the_mutex->lock = initial_lock; 10aedb: 89 42 50 mov %eax,0x50(%edx) <== NOT EXECUTED the_mutex->blocked_count = 0; 10aede: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx) <== NOT EXECUTED if ( initial_lock == CORE_MUTEX_LOCKED ) { 10aee5: 85 c0 test %eax,%eax <== NOT EXECUTED 10aee7: 75 33 jne 10af1c <_CORE_mutex_Initialize+0x5c> <== NOT EXECUTED the_mutex->nest_count = 1; 10aee9: c7 42 54 01 00 00 00 movl $0x1,0x54(%edx) <== NOT EXECUTED the_mutex->holder = _Thread_Executing; 10aef0: 8b 0d bc ea 11 00 mov 0x11eabc,%ecx <== NOT EXECUTED 10aef6: 89 4a 5c mov %ecx,0x5c(%edx) <== NOT EXECUTED the_mutex->holder_id = _Thread_Executing->Object.id; 10aef9: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10aefc: 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 10aeff: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 10af02: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10af05: 74 05 je 10af0c <_CORE_mutex_Initialize+0x4c> <== NOT EXECUTED 10af07: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10af0a: 75 25 jne 10af31 <_CORE_mutex_Initialize+0x71> <== NOT EXECUTED _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 10af0c: 8b 41 14 mov 0x14(%ecx),%eax <== NOT EXECUTED 10af0f: 3b 42 4c cmp 0x4c(%edx),%eax <== NOT EXECUTED 10af12: 72 48 jb 10af5c <_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++; 10af14: ff 41 1c incl 0x1c(%ecx) <== NOT EXECUTED 10af17: eb 18 jmp 10af31 <_CORE_mutex_Initialize+0x71> <== NOT EXECUTED 10af19: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } } else { the_mutex->nest_count = 0; 10af1c: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) <== NOT EXECUTED the_mutex->holder = NULL; 10af23: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx) <== NOT EXECUTED the_mutex->holder_id = 0; 10af2a: c7 42 60 00 00 00 00 movl $0x0,0x60(%edx) <== NOT EXECUTED } _Thread_queue_Initialize( 10af31: 6a 05 push $0x5 <== NOT EXECUTED 10af33: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 10af38: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10af3b: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10af3e: 85 c0 test %eax,%eax <== NOT EXECUTED 10af40: 0f 95 c0 setne %al <== NOT EXECUTED 10af43: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10af46: 50 push %eax <== NOT EXECUTED 10af47: 52 push %edx <== NOT EXECUTED 10af48: e8 8f 1a 00 00 call 10c9dc <_Thread_queue_Initialize> <== NOT EXECUTED 10af4d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10af4f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10af52: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10af55: 5e pop %esi <== NOT EXECUTED 10af56: 5f pop %edi <== NOT EXECUTED 10af57: c9 leave <== NOT EXECUTED 10af58: c3 ret <== NOT EXECUTED 10af59: 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 < 10af5c: b8 06 00 00 00 mov $0x6,%eax <== NOT EXECUTED STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10af61: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10af64: 5e pop %esi <== NOT EXECUTED 10af65: 5f pop %edi <== NOT EXECUTED 10af66: c9 leave <== NOT EXECUTED 10af67: c3 ret <== NOT EXECUTED 0010afb8 <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10afb8: 55 push %ebp <== NOT EXECUTED 10afb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10afbb: 56 push %esi <== NOT EXECUTED 10afbc: 53 push %ebx <== NOT EXECUTED 10afbd: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10afc0: 8a 5d 10 mov 0x10(%ebp),%bl <== NOT EXECUTED _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10afc3: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10afc8: 85 c0 test %eax,%eax <== NOT EXECUTED 10afca: 74 04 je 10afd0 <_CORE_mutex_Seize+0x18> <== NOT EXECUTED 10afcc: 84 db test %bl,%bl <== NOT EXECUTED 10afce: 75 30 jne 10b000 <_CORE_mutex_Seize+0x48> <== NOT EXECUTED 10afd0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10afd3: 8d 45 18 lea 0x18(%ebp),%eax <== NOT EXECUTED 10afd6: 50 push %eax <== NOT EXECUTED 10afd7: 56 push %esi <== NOT EXECUTED 10afd8: e8 43 41 00 00 call 10f120 <_CORE_mutex_Seize_interrupt_trylock> <== NOT EXECUTED 10afdd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10afe0: 85 c0 test %eax,%eax <== NOT EXECUTED 10afe2: 74 14 je 10aff8 <_CORE_mutex_Seize+0x40> <== NOT EXECUTED 10afe4: 84 db test %bl,%bl <== NOT EXECUTED 10afe6: 75 30 jne 10b018 <_CORE_mutex_Seize+0x60> <== NOT EXECUTED 10afe8: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10afeb: 9d popf <== NOT EXECUTED 10afec: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED 10aff1: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) <== NOT EXECUTED } 10aff8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10affb: 5b pop %ebx <== NOT EXECUTED 10affc: 5e pop %esi <== NOT EXECUTED 10affd: c9 leave <== NOT EXECUTED 10affe: c3 ret <== NOT EXECUTED 10afff: 90 nop <== NOT EXECUTED bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10b000: 83 3d c4 eb 11 00 01 cmpl $0x1,0x11ebc4 <== NOT EXECUTED 10b007: 76 c7 jbe 10afd0 <_CORE_mutex_Seize+0x18> <== NOT EXECUTED 10b009: 53 push %ebx <== NOT EXECUTED 10b00a: 6a 13 push $0x13 <== NOT EXECUTED 10b00c: 6a 00 push $0x0 <== NOT EXECUTED 10b00e: 6a 00 push $0x0 <== NOT EXECUTED 10b010: e8 c7 04 00 00 call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED 10b015: 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 10b018: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) <== NOT EXECUTED 10b01f: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED 10b024: 89 70 44 mov %esi,0x44(%eax) <== NOT EXECUTED 10b027: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10b02a: 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 10b02d: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10b032: 40 inc %eax <== NOT EXECUTED 10b033: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED 10b038: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10b03b: 9d popf <== NOT EXECUTED 10b03c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b03f: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10b042: 56 push %esi <== NOT EXECUTED 10b043: e8 20 ff ff ff call 10af68 <_CORE_mutex_Seize_interrupt_blocking> <== NOT EXECUTED 10b048: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b04b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b04e: 5b pop %ebx <== NOT EXECUTED 10b04f: 5e pop %esi <== NOT EXECUTED 10b050: c9 leave <== NOT EXECUTED 10b051: c3 ret <== NOT EXECUTED 0010af68 <_CORE_mutex_Seize_interrupt_blocking>: void _CORE_mutex_Seize_interrupt_blocking( CORE_mutex_Control *the_mutex, Watchdog_Interval timeout ) { 10af68: 55 push %ebp <== NOT EXECUTED 10af69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10af6b: 56 push %esi <== NOT EXECUTED 10af6c: 53 push %ebx <== NOT EXECUTED 10af6d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10af70: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 10af73: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ) { 10af78: 83 7b 48 02 cmpl $0x2,0x48(%ebx) <== NOT EXECUTED 10af7c: 74 1e je 10af9c <_CORE_mutex_Seize_interrupt_blocking+0x34> <== NOT EXECUTED FALSE ); } } the_mutex->blocked_count++; 10af7e: ff 43 58 incl 0x58(%ebx) <== NOT EXECUTED _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); 10af81: 50 push %eax <== NOT EXECUTED 10af82: 68 b8 ca 10 00 push $0x10cab8 <== NOT EXECUTED 10af87: 56 push %esi <== NOT EXECUTED 10af88: 53 push %ebx <== NOT EXECUTED 10af89: e8 da 17 00 00 call 10c768 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 10af8e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10af91: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10af94: 5b pop %ebx <== NOT EXECUTED 10af95: 5e pop %esi <== NOT EXECUTED 10af96: c9 leave <== NOT EXECUTED } the_mutex->blocked_count++; _Thread_queue_Enqueue( &the_mutex->Wait_queue, timeout ); _Thread_Enable_dispatch(); 10af97: e9 0c 13 00 00 jmp 10c2a8 <_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 ) { 10af9c: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED 10af9f: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10afa2: 39 42 14 cmp %eax,0x14(%edx) <== NOT EXECUTED 10afa5: 76 d7 jbe 10af7e <_CORE_mutex_Seize_interrupt_blocking+0x16> <== NOT EXECUTED _Thread_Change_priority( 10afa7: 51 push %ecx <== NOT EXECUTED 10afa8: 6a 00 push $0x0 <== NOT EXECUTED 10afaa: 50 push %eax <== NOT EXECUTED 10afab: 52 push %edx <== NOT EXECUTED 10afac: e8 1b 0e 00 00 call 10bdcc <_Thread_Change_priority> <== NOT EXECUTED 10afb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10afb4: eb c8 jmp 10af7e <_CORE_mutex_Seize_interrupt_blocking+0x16> <== NOT EXECUTED 0010f120 <_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 ) { 10f120: 55 push %ebp <== NOT EXECUTED 10f121: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f123: 53 push %ebx <== NOT EXECUTED 10f124: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10f127: 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 ); 10f12a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f12d: 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. * 10f12f: 8b 15 bc ea 11 00 mov 0x11eabc,%edx <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10f135: 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 10f13c: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 10f13f: 85 c0 test %eax,%eax <== NOT EXECUTED 10f141: 74 2d je 10f170 <_CORE_mutex_Seize_interrupt_trylock+0x50> <== NOT EXECUTED * to be resized 10f143: c7 41 50 00 00 00 00 movl $0x0,0x50(%ecx) <== NOT EXECUTED * @param[in] size is the new size 10f14a: 89 51 5c mov %edx,0x5c(%ecx) <== NOT EXECUTED * 10f14d: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10f150: 89 41 60 mov %eax,0x60(%ecx) <== NOT EXECUTED * @return TRUE if successfully able to resize the block. 10f153: 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 10f15a: 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. 10f15d: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10f160: 74 1e je 10f180 <_CORE_mutex_Seize_interrupt_trylock+0x60> <== NOT EXECUTED 10f162: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10f165: 74 19 je 10f180 <_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 10f167: 53 push %ebx <== NOT EXECUTED 10f168: 9d popf <== NOT EXECUTED 10f169: 31 c0 xor %eax,%eax <== NOT EXECUTED return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 10f16b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f16e: c9 leave <== NOT EXECUTED 10f16f: 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. 10f170: 3b 51 5c cmp 0x5c(%ecx),%edx <== NOT EXECUTED 10f173: 74 3f je 10f1b4 <_CORE_mutex_Seize_interrupt_trylock+0x94> <== NOT EXECUTED Heap_Control *the_heap, Heap_Information *info ); #ifdef __cplusplus } 10f175: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10f17a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f17d: c9 leave <== NOT EXECUTED 10f17e: c3 ret <== NOT EXECUTED 10f17f: 90 nop <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10f180: 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. * 10f183: 83 79 48 03 cmpl $0x3,0x48(%ecx) <== NOT EXECUTED 10f187: 75 de jne 10f167 <_CORE_mutex_Seize_interrupt_trylock+0x47> <== NOT EXECUTED void *start_address ); /** * This routine walks the heap to verify its integrity. * 10f189: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10f18c: 39 41 4c cmp %eax,0x4c(%ecx) <== NOT EXECUTED 10f18f: 74 47 je 10f1d8 <_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. */ 10f191: 72 4d jb 10f1e0 <_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 10f193: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) <== NOT EXECUTED * 10f19a: c7 41 50 01 00 00 00 movl $0x1,0x50(%ecx) <== NOT EXECUTED * @return true if successfully able to return information 10f1a1: c7 41 54 00 00 00 00 movl $0x0,0x54(%ecx) <== NOT EXECUTED */ 10f1a8: ff 4a 1c decl 0x1c(%edx) <== NOT EXECUTED bool _Protected_heap_Get_information( 10f1ab: 53 push %ebx <== NOT EXECUTED 10f1ac: 9d popf <== NOT EXECUTED 10f1ad: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f1af: eb c9 jmp 10f17a <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 10f1b1: 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. */ 10f1b4: 8b 41 40 mov 0x40(%ecx),%eax <== NOT EXECUTED 10f1b7: 85 c0 test %eax,%eax <== NOT EXECUTED 10f1b9: 74 11 je 10f1cc <_CORE_mutex_Seize_interrupt_trylock+0xac> <== NOT EXECUTED 10f1bb: 48 dec %eax <== NOT EXECUTED 10f1bc: 75 b7 jne 10f175 <_CORE_mutex_Seize_interrupt_trylock+0x55> <== NOT EXECUTED bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ); #ifdef __cplusplus 10f1be: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) <== NOT EXECUTED } 10f1c5: 53 push %ebx <== NOT EXECUTED 10f1c6: 9d popf <== NOT EXECUTED 10f1c7: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f1c9: eb af jmp 10f17a <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 10f1cb: 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, 10f1cc: ff 41 54 incl 0x54(%ecx) <== NOT EXECUTED Heap_Information *info 10f1cf: 53 push %ebx <== NOT EXECUTED 10f1d0: 9d popf <== NOT EXECUTED 10f1d1: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f1d3: eb a5 jmp 10f17a <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 10f1d5: 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 10f1d8: 53 push %ebx <== NOT EXECUTED 10f1d9: 9d popf <== NOT EXECUTED 10f1da: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f1dc: eb 9c jmp 10f17a <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 10f1de: 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 10f1e0: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10f1e5: 40 inc %eax <== NOT EXECUTED 10f1e6: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== 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, 10f1eb: 53 push %ebx <== NOT EXECUTED 10f1ec: 9d popf <== NOT EXECUTED int source, 10f1ed: 50 push %eax <== NOT EXECUTED 10f1ee: 6a 00 push $0x0 <== NOT EXECUTED 10f1f0: ff 71 4c pushl 0x4c(%ecx) <== NOT EXECUTED 10f1f3: ff 71 5c pushl 0x5c(%ecx) <== NOT EXECUTED 10f1f6: e8 d1 cb ff ff call 10bdcc <_Thread_Change_priority> <== NOT EXECUTED bool do_dump ); /** * This routine walks the heap and tots up the free and allocated 10f1fb: e8 a8 d0 ff ff call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED 10f200: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f202: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f205: e9 70 ff ff ff jmp 10f17a <_CORE_mutex_Seize_interrupt_trylock+0x5a> <== NOT EXECUTED 0010b054 <_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 ) { 10b054: 55 push %ebp <== NOT EXECUTED 10b055: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b057: 53 push %ebx <== NOT EXECUTED 10b058: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b05b: 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; 10b05e: 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 ) { 10b061: 80 7b 44 00 cmpb $0x0,0x44(%ebx) <== NOT EXECUTED 10b065: 74 15 je 10b07c <_CORE_mutex_Surrender+0x28> <== NOT EXECUTED if ( !_Thread_Is_executing( holder ) ) 10b067: 3b 15 bc ea 11 00 cmp 0x11eabc,%edx <== NOT EXECUTED 10b06d: 74 0d je 10b07c <_CORE_mutex_Surrender+0x28> <== NOT EXECUTED 10b06f: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 10b074: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b077: c9 leave <== NOT EXECUTED 10b078: c3 ret <== NOT EXECUTED 10b079: 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 ) 10b07c: 8b 43 54 mov 0x54(%ebx),%eax <== NOT EXECUTED 10b07f: 85 c0 test %eax,%eax <== NOT EXECUTED 10b081: 74 69 je 10b0ec <_CORE_mutex_Surrender+0x98> <== NOT EXECUTED return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 10b083: 48 dec %eax <== NOT EXECUTED 10b084: 89 43 54 mov %eax,0x54(%ebx) <== NOT EXECUTED if ( the_mutex->nest_count != 0 ) { 10b087: 85 c0 test %eax,%eax <== NOT EXECUTED 10b089: 75 69 jne 10b0f4 <_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 10b08b: 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 ) || 10b08e: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b091: 0f 84 91 00 00 00 je 10b128 <_CORE_mutex_Surrender+0xd4> <== NOT EXECUTED 10b097: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b09a: 0f 84 88 00 00 00 je 10b128 <_CORE_mutex_Surrender+0xd4> <== NOT EXECUTED } first_node = _Chain_Get_first_unprotected(&holder->lock_mutex); #endif holder->resource_count--; } the_mutex->holder = NULL; 10b0a0: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = 0; 10b0a7: 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 ) || 10b0ae: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b0b1: 74 55 je 10b108 <_CORE_mutex_Surrender+0xb4> <== NOT EXECUTED 10b0b3: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b0b6: 74 50 je 10b108 <_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 ) ) ) { 10b0b8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b0bb: 53 push %ebx <== NOT EXECUTED 10b0bc: e8 6b 15 00 00 call 10c62c <_Thread_queue_Dequeue> <== NOT EXECUTED 10b0c1: 89 c2 mov %eax,%edx <== NOT EXECUTED 10b0c3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b0c6: 85 c0 test %eax,%eax <== NOT EXECUTED 10b0c8: 0f 84 8e 00 00 00 je 10b15c <_CORE_mutex_Surrender+0x108> <== NOT EXECUTED } else #endif { the_mutex->holder = the_thread; 10b0ce: 89 43 5c mov %eax,0x5c(%ebx) <== NOT EXECUTED the_mutex->holder_id = the_thread->Object.id; 10b0d1: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10b0d4: 89 43 60 mov %eax,0x60(%ebx) <== NOT EXECUTED the_mutex->nest_count = 1; 10b0d7: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) <== NOT EXECUTED switch ( the_mutex->Attributes.discipline ) { 10b0de: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10b0e1: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10b0e4: 74 6a je 10b150 <_CORE_mutex_Surrender+0xfc> <== NOT EXECUTED 10b0e6: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b0e9: 74 45 je 10b130 <_CORE_mutex_Surrender+0xdc> <== NOT EXECUTED 10b0eb: 90 nop <== NOT EXECUTED } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 10b0ec: 31 c0 xor %eax,%eax <== NOT EXECUTED return CORE_MUTEX_STATUS_SUCCESSFUL; } 10b0ee: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b0f1: c9 leave <== NOT EXECUTED 10b0f2: c3 ret <== NOT EXECUTED 10b0f3: 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 ) { 10b0f4: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10b0f7: 85 c0 test %eax,%eax <== NOT EXECUTED 10b0f9: 74 f1 je 10b0ec <_CORE_mutex_Surrender+0x98> <== NOT EXECUTED 10b0fb: 48 dec %eax <== NOT EXECUTED 10b0fc: 75 8d jne 10b08b <_CORE_mutex_Surrender+0x37> <== NOT EXECUTED 10b0fe: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10b103: e9 6c ff ff ff jmp 10b074 <_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 && 10b108: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 10b10b: 85 c0 test %eax,%eax <== NOT EXECUTED 10b10d: 75 a9 jne 10b0b8 <_CORE_mutex_Surrender+0x64> <== NOT EXECUTED 10b10f: 8b 42 18 mov 0x18(%edx),%eax <== NOT EXECUTED 10b112: 3b 42 14 cmp 0x14(%edx),%eax <== NOT EXECUTED 10b115: 74 a1 je 10b0b8 <_CORE_mutex_Surrender+0x64> <== NOT EXECUTED holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 10b117: 51 push %ecx <== NOT EXECUTED 10b118: 6a 01 push $0x1 <== NOT EXECUTED 10b11a: 50 push %eax <== NOT EXECUTED 10b11b: 52 push %edx <== NOT EXECUTED 10b11c: e8 ab 0c 00 00 call 10bdcc <_Thread_Change_priority> <== NOT EXECUTED 10b121: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b124: eb 92 jmp 10b0b8 <_CORE_mutex_Surrender+0x64> <== NOT EXECUTED 10b126: 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--; 10b128: ff 4a 1c decl 0x1c(%edx) <== NOT EXECUTED 10b12b: e9 70 ff ff ff jmp 10b0a0 <_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++; 10b130: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED if (the_mutex->Attributes.priority_ceiling < 10b133: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10b136: 3b 42 14 cmp 0x14(%edx),%eax <== NOT EXECUTED 10b139: 73 b1 jae 10b0ec <_CORE_mutex_Surrender+0x98> <== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 10b13b: 51 push %ecx <== NOT EXECUTED 10b13c: 6a 00 push $0x0 <== NOT EXECUTED 10b13e: 50 push %eax <== NOT EXECUTED 10b13f: 52 push %edx <== NOT EXECUTED 10b140: e8 87 0c 00 00 call 10bdcc <_Thread_Change_priority> <== NOT EXECUTED 10b145: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b147: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b14a: e9 25 ff ff ff jmp 10b074 <_CORE_mutex_Surrender+0x20> <== NOT EXECUTED 10b14f: 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++; 10b150: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED 10b153: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b155: e9 1a ff ff ff jmp 10b074 <_CORE_mutex_Surrender+0x20> <== NOT EXECUTED 10b15a: 66 90 xchg %ax,%ax <== NOT EXECUTED } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 10b15c: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx) <== NOT EXECUTED 10b163: 31 c0 xor %eax,%eax 10b165: e9 0a ff ff ff jmp 10b074 <_CORE_mutex_Surrender+0x20> <== NOT EXECUTED 0010b16c <_CORE_semaphore_Flush>: void _CORE_semaphore_Flush( CORE_semaphore_Control *the_semaphore, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 10b16c: 55 push %ebp <== NOT EXECUTED 10b16d: 89 e5 mov %esp,%ebp <== NOT EXECUTED &the_semaphore->Wait_queue, remote_extract_callout, status ); } 10b16f: c9 leave <== NOT EXECUTED Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { _Thread_queue_Flush( 10b170: e9 3b 18 00 00 jmp 10c9b0 <_Thread_queue_Flush> <== NOT EXECUTED 0010b178 <_CORE_semaphore_Initialize>: void _CORE_semaphore_Initialize( CORE_semaphore_Control *the_semaphore, CORE_semaphore_Attributes *the_semaphore_attributes, uint32_t initial_value ) { 10b178: 55 push %ebp <== NOT EXECUTED 10b179: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b17b: 53 push %ebx <== NOT EXECUTED 10b17c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b17f: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b182: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED the_semaphore->Attributes = *the_semaphore_attributes; 10b185: 8b 1a mov (%edx),%ebx <== NOT EXECUTED 10b187: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10b18a: 89 41 44 mov %eax,0x44(%ecx) <== NOT EXECUTED 10b18d: 89 59 40 mov %ebx,0x40(%ecx) <== NOT EXECUTED the_semaphore->count = initial_value; 10b190: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b193: 89 41 48 mov %eax,0x48(%ecx) <== NOT EXECUTED _Thread_queue_Initialize( 10b196: 6a 03 push $0x3 <== NOT EXECUTED 10b198: 68 00 02 00 00 push $0x200 <== NOT EXECUTED 10b19d: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b19f: 83 7a 04 01 cmpl $0x1,0x4(%edx) <== NOT EXECUTED 10b1a3: 0f 94 c0 sete %al <== NOT EXECUTED 10b1a6: 50 push %eax <== NOT EXECUTED 10b1a7: 51 push %ecx <== NOT EXECUTED 10b1a8: e8 2f 18 00 00 call 10c9dc <_Thread_queue_Initialize> <== NOT EXECUTED 10b1ad: 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 ); } 10b1b0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b1b3: c9 leave <== NOT EXECUTED 10b1b4: c3 ret <== NOT EXECUTED 0010b1b8 <_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 ) { 10b1b8: 55 push %ebp <== NOT EXECUTED 10b1b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b1bb: 53 push %ebx <== NOT EXECUTED 10b1bc: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10b1bf: 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)) ) { 10b1c2: 53 push %ebx <== NOT EXECUTED 10b1c3: e8 64 14 00 00 call 10c62c <_Thread_queue_Dequeue> <== NOT EXECUTED 10b1c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b1cb: 85 c0 test %eax,%eax <== NOT EXECUTED 10b1cd: 74 09 je 10b1d8 <_CORE_semaphore_Surrender+0x20> <== NOT EXECUTED 10b1cf: 31 c0 xor %eax,%eax <== NOT EXECUTED status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); } return status; } 10b1d1: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b1d4: c9 leave <== NOT EXECUTED 10b1d5: c3 ret <== NOT EXECUTED 10b1d6: 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 ); 10b1d8: 9c pushf <== NOT EXECUTED 10b1d9: fa cli <== NOT EXECUTED 10b1da: 5a pop %edx <== NOT EXECUTED if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10b1db: 8b 43 48 mov 0x48(%ebx),%eax <== NOT EXECUTED 10b1de: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10b1e1: 72 0d jb 10b1f0 <_CORE_semaphore_Surrender+0x38> <== NOT EXECUTED 10b1e3: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); 10b1e8: 52 push %edx <== NOT EXECUTED 10b1e9: 9d popf <== NOT EXECUTED } return status; } 10b1ea: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b1ed: c9 leave <== NOT EXECUTED 10b1ee: c3 ret <== NOT EXECUTED 10b1ef: 90 nop <== NOT EXECUTED #endif } else { _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) the_semaphore->count += 1; 10b1f0: 40 inc %eax <== NOT EXECUTED 10b1f1: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 10b1f4: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b1f6: eb f0 jmp 10b1e8 <_CORE_semaphore_Surrender+0x30> <== NOT EXECUTED 0010ad38 <_Chain_Append>: void _Chain_Append( Chain_Control *the_chain, Chain_Node *node ) { 10ad38: 55 push %ebp <== NOT EXECUTED 10ad39: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad3b: 53 push %ebx <== NOT EXECUTED 10ad3c: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ad3f: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10ad42: 9c pushf <== NOT EXECUTED 10ad43: fa cli <== NOT EXECUTED 10ad44: 5b pop %ebx <== NOT EXECUTED 10ad45: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10ad48: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10ad4a: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10ad4d: 89 51 08 mov %edx,0x8(%ecx) <== NOT EXECUTED 10ad50: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10ad52: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED _Chain_Append_unprotected( the_chain, node ); _ISR_Enable( level ); 10ad55: 53 push %ebx <== NOT EXECUTED 10ad56: 9d popf <== NOT EXECUTED } 10ad57: 5b pop %ebx <== NOT EXECUTED 10ad58: c9 leave <== NOT EXECUTED 10ad59: c3 ret <== NOT EXECUTED 0010efdc <_Chain_Extract>: */ void _Chain_Extract( Chain_Node *node ) { 10efdc: 55 push %ebp <== NOT EXECUTED 10efdd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10efdf: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10efe2: 9c pushf <== NOT EXECUTED 10efe3: fa cli <== NOT EXECUTED 10efe4: 59 pop %ecx <== NOT EXECUTED 10efe5: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10efe7: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10efea: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10efed: 89 10 mov %edx,(%eax) <== NOT EXECUTED _Chain_Extract_unprotected( node ); _ISR_Enable( level ); 10efef: 51 push %ecx <== NOT EXECUTED 10eff0: 9d popf <== NOT EXECUTED } 10eff1: c9 leave <== NOT EXECUTED 10eff2: c3 ret <== NOT EXECUTED 0010ad5c <_Chain_Get>: */ Chain_Node *_Chain_Get( Chain_Control *the_chain ) { 10ad5c: 55 push %ebp <== NOT EXECUTED 10ad5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ad5f: 53 push %ebx <== NOT EXECUTED 10ad60: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Chain_Node *return_node; return_node = NULL; _ISR_Disable( level ); 10ad63: 9c pushf <== NOT EXECUTED 10ad64: fa cli <== NOT EXECUTED 10ad65: 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( 10ad66: 8b 11 mov (%ecx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( the_chain ) ) 10ad68: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10ad6b: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10ad6d: 74 11 je 10ad80 <_Chain_Get+0x24> <== NOT EXECUTED 10ad6f: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10ad71: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10ad73: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED return_node = _Chain_Get_first_unprotected( the_chain ); _ISR_Enable( level ); 10ad76: 53 push %ebx <== NOT EXECUTED 10ad77: 9d popf <== NOT EXECUTED return return_node; } 10ad78: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ad7a: 5b pop %ebx <== NOT EXECUTED 10ad7b: c9 leave <== NOT EXECUTED 10ad7c: c3 ret <== NOT EXECUTED 10ad7d: 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 ) ) 10ad80: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ad82: eb f2 jmp 10ad76 <_Chain_Get+0x1a> <== NOT EXECUTED 0010eff4 <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10eff4: 55 push %ebp <== NOT EXECUTED 10eff5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eff7: 57 push %edi <== NOT EXECUTED 10eff8: 56 push %esi <== NOT EXECUTED 10eff9: 53 push %ebx <== NOT EXECUTED 10effa: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10effd: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10f000: 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 10f003: 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; 10f005: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) <== NOT EXECUTED next = starting_address; while ( count-- ) { 10f00c: 85 c0 test %eax,%eax <== NOT EXECUTED 10f00e: 74 22 je 10f032 <_Chain_Initialize+0x3e> <== NOT EXECUTED 10f010: 8d 50 ff lea -0x1(%eax),%edx <== NOT EXECUTED 10f013: 89 d7 mov %edx,%edi <== NOT EXECUTED 10f015: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f018: eb 03 jmp 10f01d <_Chain_Initialize+0x29> <== NOT EXECUTED 10f01a: 66 90 xchg %ax,%ax <== NOT EXECUTED 10f01c: 4a dec %edx <== NOT EXECUTED current->next = next; 10f01d: 89 01 mov %eax,(%ecx) <== NOT EXECUTED next->previous = current; 10f01f: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10f022: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10f024: 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-- ) { 10f026: 85 d2 test %edx,%edx <== NOT EXECUTED 10f028: 75 f2 jne 10f01c <_Chain_Initialize+0x28> <== NOT EXECUTED 10f02a: 0f af df imul %edi,%ebx <== NOT EXECUTED 10f02d: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10f030: 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 ); 10f032: 8d 46 04 lea 0x4(%esi),%eax <== NOT EXECUTED 10f035: 89 01 mov %eax,(%ecx) <== NOT EXECUTED the_chain->last = current; 10f037: 89 4e 08 mov %ecx,0x8(%esi) <== NOT EXECUTED } 10f03a: 5b pop %ebx <== NOT EXECUTED 10f03b: 5e pop %esi <== NOT EXECUTED 10f03c: 5f pop %edi <== NOT EXECUTED 10f03d: c9 leave <== NOT EXECUTED 10f03e: c3 ret <== NOT EXECUTED 00126454 <_Chain_Insert>: void _Chain_Insert( Chain_Node *after_node, Chain_Node *node ) { 126454: 55 push %ebp <== NOT EXECUTED 126455: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126457: 53 push %ebx <== NOT EXECUTED 126458: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 12645b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 12645e: 9c pushf <== NOT EXECUTED 12645f: fa cli <== NOT EXECUTED 126460: 5b pop %ebx <== NOT EXECUTED 126461: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED 126464: 8b 0a mov (%edx),%ecx <== NOT EXECUTED 126466: 89 02 mov %eax,(%edx) <== NOT EXECUTED 126468: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 12646a: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED _Chain_Insert_unprotected( after_node, node ); _ISR_Enable( level ); 12646d: 53 push %ebx <== NOT EXECUTED 12646e: 9d popf <== NOT EXECUTED } 12646f: 5b pop %ebx <== NOT EXECUTED 126470: c9 leave <== NOT EXECUTED 126471: c3 ret <== NOT EXECUTED 0010ef88 <_Debug_Is_enabled>: */ bool _Debug_Is_enabled( rtems_debug_control level ) { 10ef88: 55 push %ebp <== NOT EXECUTED 10ef89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ef8b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ef8e: 85 05 c0 ea 11 00 test %eax,0x11eac0 <== NOT EXECUTED 10ef94: 0f 95 c0 setne %al <== NOT EXECUTED return (_Debug_Level & level) ? true : false; } 10ef97: c9 leave <== NOT EXECUTED 10ef98: c3 ret <== NOT EXECUTED 0010ef58 <_Debug_Manager_initialization>: * * _Debug_Manager_initialization */ void _Debug_Manager_initialization( void ) { 10ef58: 55 push %ebp <== NOT EXECUTED 10ef59: 89 e5 mov %esp,%ebp <== NOT EXECUTED void rtems_debug_disable ( rtems_debug_control to_be_disabled ) { _Debug_Level &= ~to_be_disabled; 10ef5b: c7 05 c0 ea 11 00 00 movl $0x0,0x11eac0 <== NOT EXECUTED 10ef62: 00 00 00 <== NOT EXECUTED */ void _Debug_Manager_initialization( void ) { rtems_debug_disable( RTEMS_DEBUG_ALL_MASK ); } 10ef65: c9 leave <== NOT EXECUTED 10ef66: c3 ret <== NOT EXECUTED 0010ebd8 <_Dual_ported_memory_Manager_initialization>: */ void _Dual_ported_memory_Manager_initialization( uint32_t maximum_ports ) { 10ebd8: 55 push %ebp <== NOT EXECUTED 10ebd9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ebdb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ebde: 6a 04 push $0x4 <== NOT EXECUTED 10ebe0: 6a 00 push $0x0 <== NOT EXECUTED 10ebe2: 6a 1c push $0x1c <== NOT EXECUTED 10ebe4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ebe7: 6a 07 push $0x7 <== NOT EXECUTED 10ebe9: 6a 02 push $0x2 <== NOT EXECUTED 10ebeb: 68 00 ee 11 00 push $0x11ee00 <== NOT EXECUTED 10ebf0: e8 d3 ce ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10ebf5: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ebf8: c9 leave <== NOT EXECUTED 10ebf9: c3 ret <== NOT EXECUTED 0010ebfc <_Event_Manager_initialization>: * * This routine performs the initialization necessary for this manager. */ void _Event_Manager_initialization( void ) { 10ebfc: 55 push %ebp <== NOT EXECUTED 10ebfd: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10ebff: c7 05 0c ed 11 00 00 movl $0x0,0x11ed0c <== NOT EXECUTED 10ec06: 00 00 00 <== NOT EXECUTED */ #if defined(RTEMS_MULTIPROCESSING) _MPCI_Register_packet_processor( MP_PACKET_EVENT, _Event_MP_Process_packet ); #endif } 10ec09: c9 leave <== NOT EXECUTED 10ec0a: 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 bc ea 11 00 mov 0x11eabc,%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 0c ed 11 00 01 movl $0x1,0x11ed0c <== 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 82 2d 00 00 call 10cb5c <_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 0c ed 11 00 mov 0x11ed0c,%eax <== NOT EXECUTED _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 109de2: c7 05 0c ed 11 00 00 movl $0x0,0x11ed0c <== 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 77 1f 00 00 jmp 10bd80 <_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 dc ea 11 00 push $0x11eadc <== NOT EXECUTED 109e79: e8 3a 33 00 00 call 10d1b8 <_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 98 ea 11 00 mov 0x11ea98,%eax <== NOT EXECUTED 109f09: 85 c0 test %eax,%eax <== NOT EXECUTED 109f0b: 74 0c je 109f19 <_Event_Surrender+0x3d> <== NOT EXECUTED 109f0d: 3b 1d bc ea 11 00 cmp 0x11eabc,%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 99 1f 00 00 call 10bf00 <_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 51 33 00 00 call 10d2e8 <_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 5c 1f 00 00 call 10bf00 <_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 0c ed 11 00 mov 0x11ed0c,%eax <== NOT EXECUTED 109fb1: 48 dec %eax <== NOT EXECUTED 109fb2: 74 0e je 109fc2 <_Event_Surrender+0xe6> <== NOT EXECUTED 109fb4: a1 0c ed 11 00 mov 0x11ed0c,%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 0c ed 11 00 03 movl $0x3,0x11ed0c <== 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 c6 22 00 00 call 10c2cc <_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 bc ea 11 00 cmp 0x11eabc,%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 be 1e 00 00 call 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 10a042: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10a047: 48 dec %eax <== NOT EXECUTED 10a048: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== 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 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10a059: 48 dec %eax <== NOT EXECUTED 10a05a: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== 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 0c ed 11 00 mov 0x11ed0c,%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 0c ed 11 00 02 movl $0x2,0x11ed0c <== NOT EXECUTED 10a075: 00 00 00 <== NOT EXECUTED 10a078: eb b1 jmp 10a02b <_Event_Timeout+0x37> <== NOT EXECUTED 0010aa1c <_Extension_Manager_initialization>: */ void _Extension_Manager_initialization( uint32_t maximum_extensions ) { 10aa1c: 55 push %ebp <== NOT EXECUTED 10aa1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa1f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10aa22: 6a 04 push $0x4 <== NOT EXECUTED 10aa24: 6a 00 push $0x0 <== NOT EXECUTED 10aa26: 6a 44 push $0x44 <== NOT EXECUTED 10aa28: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10aa2b: 6a 09 push $0x9 <== NOT EXECUTED 10aa2d: 6a 02 push $0x2 <== NOT EXECUTED 10aa2f: 68 60 ed 11 00 push $0x11ed60 <== NOT EXECUTED 10aa34: e8 8f 10 00 00 call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10aa39: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , false, /* true if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10aa3c: c9 leave <== NOT EXECUTED 10aa3d: c3 ret <== NOT EXECUTED 0010f260 <_Heap_Allocate>: void *_Heap_Allocate( Heap_Control *the_heap, size_t size ) { 10f260: 55 push %ebp <== NOT EXECUTED 10f261: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f263: 57 push %edi <== NOT EXECUTED 10f264: 56 push %esi <== NOT EXECUTED 10f265: 53 push %ebx <== NOT EXECUTED 10f266: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10f269: 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 = 10f26c: ff 77 14 pushl 0x14(%edi) <== NOT EXECUTED 10f26f: ff 77 10 pushl 0x10(%edi) <== NOT EXECUTED 10f272: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10f275: e8 aa c1 ff ff call 10b424 <_Heap_Calc_block_size> <== NOT EXECUTED _Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size); if(the_size == 0) 10f27a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f27d: 85 c0 test %eax,%eax <== NOT EXECUTED 10f27f: 74 3b je 10f2bc <_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( 10f281: 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; 10f284: 39 df cmp %ebx,%edi <== NOT EXECUTED 10f286: 74 34 je 10f2bc <_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) { 10f288: 3b 43 04 cmp 0x4(%ebx),%eax <== NOT EXECUTED 10f28b: 76 5c jbe 10f2e9 <_Heap_Allocate+0x89> <== NOT EXECUTED stats->allocs += 1; stats->searches += search_count + 1; _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; 10f28d: 31 f6 xor %esi,%esi <== NOT EXECUTED 10f28f: eb 08 jmp 10f299 <_Heap_Allocate+0x39> <== NOT EXECUTED 10f291: 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) { 10f294: 3b 43 04 cmp 0x4(%ebx),%eax <== NOT EXECUTED 10f297: 76 2f jbe 10f2c8 <_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) 10f299: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED 10f29c: 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; 10f29d: 39 df cmp %ebx,%edi <== NOT EXECUTED 10f29f: 75 f3 jne 10f294 <_Heap_Allocate+0x34> <== NOT EXECUTED 10f2a1: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED 10f2a4: 31 d2 xor %edx,%edx <== NOT EXECUTED _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 10f2a6: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10f2a9: 39 47 44 cmp %eax,0x44(%edi) <== NOT EXECUTED 10f2ac: 73 03 jae 10f2b1 <_Heap_Allocate+0x51> <== NOT EXECUTED stats->max_search = search_count; 10f2ae: 89 47 44 mov %eax,0x44(%edi) <== NOT EXECUTED return ptr; } 10f2b1: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f2b3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f2b6: 5b pop %ebx <== NOT EXECUTED 10f2b7: 5e pop %esi <== NOT EXECUTED 10f2b8: 5f pop %edi <== NOT EXECUTED 10f2b9: c9 leave <== NOT EXECUTED 10f2ba: c3 ret <== NOT EXECUTED 10f2bb: 90 nop <== NOT EXECUTED break; } } if(stats->max_search < search_count) stats->max_search = search_count; 10f2bc: 31 d2 xor %edx,%edx <== NOT EXECUTED return ptr; } 10f2be: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f2c0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f2c3: 5b pop %ebx <== NOT EXECUTED 10f2c4: 5e pop %esi <== NOT EXECUTED 10f2c5: 5f pop %edi <== NOT EXECUTED 10f2c6: c9 leave <== NOT EXECUTED 10f2c7: 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) { 10f2c8: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED (void)_Heap_Block_allocate(the_heap, the_block, the_size ); 10f2cb: 52 push %edx <== NOT EXECUTED 10f2cc: 50 push %eax <== NOT EXECUTED 10f2cd: 53 push %ebx <== NOT EXECUTED 10f2ce: 57 push %edi <== NOT EXECUTED 10f2cf: e8 84 c1 ff ff call 10b458 <_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 10f2d4: 8d 53 08 lea 0x8(%ebx),%edx <== NOT EXECUTED ptr = _Heap_User_area(the_block); stats->allocs += 1; 10f2d7: ff 47 48 incl 0x48(%edi) <== NOT EXECUTED stats->searches += search_count + 1; 10f2da: 8b 47 4c mov 0x4c(%edi),%eax <== NOT EXECUTED 10f2dd: 8d 44 06 01 lea 0x1(%esi,%eax,1),%eax <== NOT EXECUTED 10f2e1: 89 47 4c mov %eax,0x4c(%edi) <== NOT EXECUTED 10f2e4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f2e7: eb bd jmp 10f2a6 <_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) { 10f2e9: 31 f6 xor %esi,%esi <== NOT EXECUTED 10f2eb: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED 10f2f2: eb d7 jmp 10f2cb <_Heap_Allocate+0x6b> <== NOT EXECUTED 0010cc1c <_Heap_Allocate_aligned>: void *_Heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 10cc1c: 55 push %ebp <== NOT EXECUTED 10cc1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cc1f: 57 push %edi <== NOT EXECUTED 10cc20: 56 push %esi <== NOT EXECUTED 10cc21: 53 push %ebx <== NOT EXECUTED 10cc22: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 10cc25: 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; 10cc28: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10cc2b: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 10cc2e: 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; 10cc31: 8d 48 fc lea -0x4(%eax),%ecx <== NOT EXECUTED 10cc34: 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); 10cc37: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10cc3a: ff 77 14 pushl 0x14(%edi) <== NOT EXECUTED 10cc3d: 52 push %edx <== NOT EXECUTED 10cc3e: 50 push %eax <== NOT EXECUTED 10cc3f: e8 8c 04 00 00 call 10d0d0 <_Heap_Calc_block_size> <== NOT EXECUTED 10cc44: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED if(the_size == 0) 10cc47: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cc4a: 85 c0 test %eax,%eax <== NOT EXECUTED 10cc4c: 0f 84 1a 01 00 00 je 10cd6c <_Heap_Allocate_aligned+0x150> <== NOT EXECUTED return NULL; if(alignment == 0) 10cc52: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10cc55: 85 c0 test %eax,%eax <== NOT EXECUTED 10cc57: 0f 84 03 01 00 00 je 10cd60 <_Heap_Allocate_aligned+0x144> <== NOT EXECUTED ) { return ( the_thread == _Thread_Heir ); } /** 10cc5d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cc60: 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; 10cc63: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10cc65: 0f 84 01 01 00 00 je 10cd6c <_Heap_Allocate_aligned+0x150> <== NOT EXECUTED 10cc6b: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED 10cc72: eb 17 jmp 10cc8b <_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) { 10cc74: 89 f2 mov %esi,%edx <== NOT EXECUTED aligned_user_addr = 0; } } } if(aligned_user_addr) { 10cc76: 85 ff test %edi,%edi <== NOT EXECUTED 10cc78: 75 7a jne 10ccf4 <_Heap_Allocate_aligned+0xd8> <== NOT EXECUTED 10cc7a: 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) 10cc7c: 8b 49 08 mov 0x8(%ecx),%ecx <== NOT EXECUTED 10cc7f: 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; 10cc82: 39 4d 08 cmp %ecx,0x8(%ebp) <== NOT EXECUTED 10cc85: 0f 84 ed 00 00 00 je 10cd78 <_Heap_Allocate_aligned+0x15c> <== NOT EXECUTED 10cc8b: 8b 59 04 mov 0x4(%ecx),%ebx <== NOT EXECUTED 10cc8e: 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. */ 10cc91: 39 5d e4 cmp %ebx,-0x1c(%ebp) <== NOT EXECUTED 10cc94: 77 e6 ja 10cc7c <_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)); 10cc96: 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; 10cc99: 8d 14 19 lea (%ecx,%ebx,1),%edx <== NOT EXECUTED 10cc9c: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED aligned_user_addr = block_end - end_to_user_offs; 10cc9f: 89 d7 mov %edx,%edi <== NOT EXECUTED 10cca1: 2b 7d e0 sub -0x20(%ebp),%edi <== NOT EXECUTED RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization( void ) { _Thread_Dispatch_disable_level = 1; } 10cca4: 89 f8 mov %edi,%eax <== NOT EXECUTED 10cca6: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cca8: f7 75 10 divl 0x10(%ebp) <== NOT EXECUTED 10ccab: 29 d7 sub %edx,%edi <== NOT EXECUTED 10ccad: 89 f8 mov %edi,%eax <== NOT EXECUTED 10ccaf: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ccb1: f7 75 dc divl -0x24(%ebp) <== NOT EXECUTED 10ccb4: 89 f8 mov %edi,%eax <== NOT EXECUTED 10ccb6: 29 d0 sub %edx,%eax <== NOT EXECUTED 10ccb8: 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) { 10ccba: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10ccbc: 77 be ja 10cc7c <_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) { 10ccbe: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ccc1: 8b 40 14 mov 0x14(%eax),%eax <== NOT EXECUTED 10ccc4: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 10ccc7: 89 d0 mov %edx,%eax <== NOT EXECUTED 10ccc9: 29 f0 sub %esi,%eax <== NOT EXECUTED 10cccb: 3b 45 ec cmp -0x14(%ebp),%eax <== NOT EXECUTED 10ccce: 73 a6 jae 10cc76 <_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) { 10ccd0: 89 f8 mov %edi,%eax <== NOT EXECUTED 10ccd2: 29 f0 sub %esi,%eax <== NOT EXECUTED 10ccd4: 39 45 dc cmp %eax,-0x24(%ebp) <== NOT EXECUTED 10ccd7: 77 9b ja 10cc74 <_Heap_Allocate_aligned+0x58> <== NOT EXECUTED RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); } /** 10ccd9: 89 f0 mov %esi,%eax <== NOT EXECUTED 10ccdb: 31 d2 xor %edx,%edx <== NOT EXECUTED 10ccdd: f7 75 10 divl 0x10(%ebp) <== NOT EXECUTED * This function returns TRUE if dispatching is disabled, and FALSE 10cce0: 85 d2 test %edx,%edx <== NOT EXECUTED 10cce2: 75 6c jne 10cd50 <_Heap_Allocate_aligned+0x134> <== NOT EXECUTED 10cce4: 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) { 10cce6: 39 55 dc cmp %edx,-0x24(%ebp) <== NOT EXECUTED 10cce9: 76 91 jbe 10cc7c <_Heap_Allocate_aligned+0x60> <== NOT EXECUTED 10cceb: 89 f2 mov %esi,%edx <== NOT EXECUTED 10cced: 89 c7 mov %eax,%edi <== NOT EXECUTED aligned_user_addr = 0; } } } if(aligned_user_addr) { 10ccef: 85 ff test %edi,%edi <== NOT EXECUTED 10ccf1: 74 89 je 10cc7c <_Heap_Allocate_aligned+0x60> <== NOT EXECUTED 10ccf3: 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; 10ccf4: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 10ccf7: 83 c6 08 add $0x8,%esi <== NOT EXECUTED 10ccfa: 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; 10ccfc: 89 da mov %ebx,%edx <== NOT EXECUTED 10ccfe: 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) { 10cd00: 3b 55 ec cmp -0x14(%ebp),%edx <== NOT EXECUTED 10cd03: 0f 82 87 00 00 00 jb 10cd90 <_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; 10cd09: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cd0b: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10cd0e: 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 ); 10cd11: 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 10cd14: 89 c1 mov %eax,%ecx <== NOT EXECUTED the_block = _Heap_Block_at(the_block, the_rest); the_block->prev_size = the_rest; 10cd16: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_block->size = alloc_size; 10cd18: 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; 10cd1b: 83 4c 31 04 01 orl $0x1,0x4(%ecx,%esi,1) <== NOT EXECUTED /* Update statistics */ stats->free_size -= alloc_size; 10cd20: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10cd23: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10cd26: 29 f0 sub %esi,%eax <== NOT EXECUTED 10cd28: 89 42 30 mov %eax,0x30(%edx) <== NOT EXECUTED if(stats->min_free_size > stats->free_size) 10cd2b: 3b 42 34 cmp 0x34(%edx),%eax <== NOT EXECUTED 10cd2e: 73 03 jae 10cd33 <_Heap_Allocate_aligned+0x117> <== NOT EXECUTED stats->min_free_size = stats->free_size; 10cd30: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED stats->used_blocks += 1; 10cd33: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10cd36: 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; 10cd39: 8b 41 4c mov 0x4c(%ecx),%eax <== NOT EXECUTED 10cd3c: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10cd3f: 8d 44 02 01 lea 0x1(%edx,%eax,1),%eax <== NOT EXECUTED 10cd43: 89 41 4c mov %eax,0x4c(%ecx) <== NOT EXECUTED stats->allocs += 1; 10cd46: 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; 10cd49: 89 f8 mov %edi,%eax <== NOT EXECUTED 10cd4b: eb 2d jmp 10cd7a <_Heap_Allocate_aligned+0x15e> <== NOT EXECUTED 10cd4d: 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 10cd50: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10cd53: 8d 04 3e lea (%esi,%edi,1),%eax <== NOT EXECUTED 10cd56: 29 d0 sub %edx,%eax <== NOT EXECUTED 10cd58: 89 c2 mov %eax,%edx <== NOT EXECUTED 10cd5a: 29 f2 sub %esi,%edx <== NOT EXECUTED 10cd5c: eb 88 jmp 10cce6 <_Heap_Allocate_aligned+0xca> <== NOT EXECUTED 10cd5e: 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) 10cd60: c7 45 10 04 00 00 00 movl $0x4,0x10(%ebp) <== NOT EXECUTED 10cd67: e9 f1 fe ff ff jmp 10cc5d <_Heap_Allocate_aligned+0x41> <== NOT EXECUTED } } } if(stats->max_search < search_count) stats->max_search = search_count; 10cd6c: 31 c0 xor %eax,%eax <== NOT EXECUTED return user_ptr; } 10cd6e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cd71: 5b pop %ebx <== NOT EXECUTED 10cd72: 5e pop %esi <== NOT EXECUTED 10cd73: 5f pop %edi <== NOT EXECUTED 10cd74: c9 leave <== NOT EXECUTED 10cd75: c3 ret <== NOT EXECUTED 10cd76: 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; 10cd78: 31 c0 xor %eax,%eax <== NOT EXECUTED } } } } if(stats->max_search < search_count) 10cd7a: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10cd7d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10cd80: 39 4f 44 cmp %ecx,0x44(%edi) <== NOT EXECUTED 10cd83: 73 e9 jae 10cd6e <_Heap_Allocate_aligned+0x152> <== NOT EXECUTED stats->max_search = search_count; 10cd85: 89 4f 44 mov %ecx,0x44(%edi) <== NOT EXECUTED return user_ptr; } 10cd88: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cd8b: 5b pop %ebx <== NOT EXECUTED 10cd8c: 5e pop %esi <== NOT EXECUTED 10cd8d: 5f pop %edi <== NOT EXECUTED 10cd8e: c9 leave <== NOT EXECUTED 10cd8f: 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 ) { 10cd90: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) 10cd93: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED if ( _Thread_Executing->fp_context != NULL ) 10cd96: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED _Context_Restore_fp( &_Thread_Executing->fp_context ); 10cd99: 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; 10cd9c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cd9f: ff 48 38 decl 0x38(%eax) <== NOT EXECUTED 10cda2: 89 de mov %ebx,%esi <== NOT EXECUTED 10cda4: e9 72 ff ff ff jmp 10cd1b <_Heap_Allocate_aligned+0xff> <== NOT EXECUTED 0010b458 <_Heap_Block_allocate>: uint32_t _Heap_Block_allocate( Heap_Control* the_heap, Heap_Block* the_block, uint32_t alloc_size ) { 10b458: 55 push %ebp <== NOT EXECUTED 10b459: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b45b: 57 push %edi <== NOT EXECUTED 10b45c: 56 push %esi <== NOT EXECUTED 10b45d: 53 push %ebx <== NOT EXECUTED 10b45e: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10b461: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10b464: 8b 4e 04 mov 0x4(%esi),%ecx <== NOT EXECUTED 10b467: 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; 10b46a: 89 cb mov %ecx,%ebx <== NOT EXECUTED 10b46c: 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) { 10b46e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b471: 3b 58 14 cmp 0x14(%eax),%ebx <== NOT EXECUTED 10b474: 72 4a jb 10b4c0 <_Heap_Block_allocate+0x68> <== NOT EXECUTED 10b476: 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 */ 10b479: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED bool _Protected_heap_Get_block_size( 10b47c: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size 10b47f: 89 4a 08 mov %ecx,0x8(%edx) <== NOT EXECUTED ); 10b482: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 10b485: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED 10b488: 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; 10b48b: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b48d: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10b490: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED next_block->size = the_rest | HEAP_PREV_USED; 10b493: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b495: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10b498: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED _Heap_Block_at(next_block, the_rest)->prev_size = the_rest; 10b49b: 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; 10b49e: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b4a1: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10b4a4: 29 f8 sub %edi,%eax <== NOT EXECUTED 10b4a6: 89 42 30 mov %eax,0x30(%edx) <== NOT EXECUTED if(stats->min_free_size > stats->free_size) 10b4a9: 3b 42 34 cmp 0x34(%edx),%eax <== NOT EXECUTED 10b4ac: 73 03 jae 10b4b1 <_Heap_Block_allocate+0x59> <== NOT EXECUTED stats->min_free_size = stats->free_size; 10b4ae: 89 42 34 mov %eax,0x34(%edx) <== NOT EXECUTED stats->used_blocks += 1; 10b4b1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b4b4: ff 40 40 incl 0x40(%eax) <== NOT EXECUTED return alloc_size; } 10b4b7: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b4b9: 5b pop %ebx <== NOT EXECUTED 10b4ba: 5e pop %esi <== NOT EXECUTED 10b4bb: 5f pop %edi <== NOT EXECUTED 10b4bc: c9 leave <== NOT EXECUTED 10b4bd: c3 ret <== NOT EXECUTED 10b4be: 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 10b4c0: 8b 56 08 mov 0x8(%esi),%edx <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes 10b4c3: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED * @param[in] alignment the required alignment 10b4c6: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10b4c9: 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; 10b4cc: 83 4c 0e 04 01 orl $0x1,0x4(%esi,%ecx,1) <== NOT EXECUTED stats->free_blocks -= 1; 10b4d1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b4d4: ff 4a 38 decl 0x38(%edx) <== NOT EXECUTED 10b4d7: 89 cf mov %ecx,%edi <== NOT EXECUTED 10b4d9: eb c3 jmp 10b49e <_Heap_Block_allocate+0x46> <== NOT EXECUTED 0010b424 <_Heap_Calc_block_size>: */ size_t _Heap_Calc_block_size( size_t size, uint32_t page_size, uint32_t min_size) { 10b424: 55 push %ebp <== NOT EXECUTED 10b425: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b427: 53 push %ebx <== NOT EXECUTED 10b428: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b42b: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD; 10b42e: 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 10b431: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b433: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b435: f7 75 0c divl 0xc(%ebp) <== NOT EXECUTED */ 10b438: 85 d2 test %edx,%edx <== NOT EXECUTED 10b43a: 74 05 je 10b441 <_Heap_Calc_block_size+0x1d> <== NOT EXECUTED 10b43c: 03 5d 0c add 0xc(%ebp),%ebx <== NOT EXECUTED 10b43f: 29 d3 sub %edx,%ebx <== NOT EXECUTED 10b441: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b443: 3b 5d 10 cmp 0x10(%ebp),%ebx <== NOT EXECUTED 10b446: 73 03 jae 10b44b <_Heap_Calc_block_size+0x27> <== NOT EXECUTED 10b448: 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; 10b44b: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10b44d: 72 02 jb 10b451 <_Heap_Calc_block_size+0x2d> <== NOT EXECUTED 10b44f: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10b451: 5a pop %edx <== NOT EXECUTED 10b452: 5b pop %ebx <== NOT EXECUTED 10b453: c9 leave <== NOT EXECUTED 10b454: c3 ret <== NOT EXECUTED 001113f8 <_Heap_Extend>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t *amount_extended ) { 1113f8: 55 push %ebp <== NOT EXECUTED 1113f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1113fb: 56 push %esi <== NOT EXECUTED 1113fc: 53 push %ebx <== NOT EXECUTED 1113fd: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 111400: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 111403: 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 */ 111406: 39 41 18 cmp %eax,0x18(%ecx) <== NOT EXECUTED 111409: 76 15 jbe 111420 <_Heap_Extend+0x28> <== NOT EXECUTED 11140b: 8b 51 1c mov 0x1c(%ecx),%edx <== NOT EXECUTED starting_address < the_heap->end ) return HEAP_EXTEND_ERROR; if ( starting_address != the_heap->end ) 11140e: 39 d0 cmp %edx,%eax <== NOT EXECUTED 111410: 74 22 je 111434 <_Heap_Extend+0x3c> <== NOT EXECUTED 111412: 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; } 111417: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11141a: 5b pop %ebx <== NOT EXECUTED 11141b: 5e pop %esi <== NOT EXECUTED 11141c: c9 leave <== NOT EXECUTED 11141d: c3 ret <== NOT EXECUTED 11141e: 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 */ 111420: 8b 51 1c mov 0x1c(%ecx),%edx <== NOT EXECUTED 111423: 39 d0 cmp %edx,%eax <== NOT EXECUTED 111425: 73 e7 jae 11140e <_Heap_Extend+0x16> <== NOT EXECUTED 111427: 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; } 11142c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11142f: 5b pop %ebx <== NOT EXECUTED 111430: 5e pop %esi <== NOT EXECUTED 111431: c9 leave <== NOT EXECUTED 111432: c3 ret <== NOT EXECUTED 111433: 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; 111434: 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 ); 111437: 03 45 10 add 0x10(%ebp),%eax <== NOT EXECUTED the_heap->end = _Addresses_Add_offset( the_heap->end, size ); 11143a: 89 41 1c mov %eax,0x1c(%ecx) <== NOT EXECUTED the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD; 11143d: 29 d8 sub %ebx,%eax <== NOT EXECUTED 11143f: 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) || \ 111442: 89 f0 mov %esi,%eax <== NOT EXECUTED 111444: 31 d2 xor %edx,%edx <== NOT EXECUTED 111446: f7 71 10 divl 0x10(%ecx) <== NOT EXECUTED 111449: 29 d6 sub %edx,%esi <== NOT EXECUTED 11144b: 89 f2 mov %esi,%edx <== NOT EXECUTED _Heap_Align_down( &the_size, the_heap->page_size ); *amount_extended = size; 11144d: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 111450: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 111453: 89 06 mov %eax,(%esi) <== NOT EXECUTED if( the_size < the_heap->min_block_size ) 111455: 39 51 14 cmp %edx,0x14(%ecx) <== NOT EXECUTED 111458: 76 06 jbe 111460 <_Heap_Extend+0x68> <== NOT EXECUTED 11145a: 31 c0 xor %eax,%eax <== NOT EXECUTED 11145c: eb b9 jmp 111417 <_Heap_Extend+0x1f> <== NOT EXECUTED 11145e: 66 90 xchg %ax,%ax <== NOT EXECUTED return HEAP_EXTEND_SUCCESSFUL; old_final->size = the_size | (old_final->size & HEAP_PREV_USED); 111460: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 111463: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 111466: 09 d0 or %edx,%eax <== NOT EXECUTED 111468: 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 11146b: 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; 11146e: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) <== NOT EXECUTED the_heap->final = new_final; 111475: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED stats->size += size; 111478: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 11147b: 01 51 2c add %edx,0x2c(%ecx) <== NOT EXECUTED stats->used_blocks += 1; 11147e: ff 41 40 incl 0x40(%ecx) <== NOT EXECUTED stats->frees -= 1; /* Don't count subsequent call as actual free() */ 111481: ff 49 50 decl 0x50(%ecx) <== NOT EXECUTED _Heap_Free( the_heap, _Heap_User_area( old_final ) ); 111484: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111487: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 11148a: 50 push %eax <== NOT EXECUTED 11148b: 51 push %ecx <== NOT EXECUTED 11148c: e8 af b9 ff ff call 10ce40 <_Heap_Free> <== NOT EXECUTED 111491: 31 c0 xor %eax,%eax <== NOT EXECUTED 111493: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111496: e9 7c ff ff ff jmp 111417 <_Heap_Extend+0x1f> <== NOT EXECUTED 0010f2f4 <_Heap_Free>: bool _Heap_Free( Heap_Control *the_heap, void *starting_address ) { 10f2f4: 55 push %ebp <== NOT EXECUTED 10f2f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f2f7: 57 push %edi <== NOT EXECUTED 10f2f8: 56 push %esi <== NOT EXECUTED 10f2f9: 53 push %ebx <== NOT EXECUTED 10f2fa: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10f2fd: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10f300: 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( 10f303: 8b 77 24 mov 0x24(%edi),%esi <== NOT EXECUTED 10f306: 8b 4f 20 mov 0x20(%edi),%ecx <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10f309: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10f30b: 77 04 ja 10f311 <_Heap_Free+0x1d> <== NOT EXECUTED 10f30d: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10f30f: 73 0b jae 10f31c <_Heap_Free+0x28> <== NOT EXECUTED stats->used_blocks -= 1; stats->free_size += the_size; stats->frees += 1; return( TRUE ); 10f311: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10f313: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10f316: 5b pop %ebx <== NOT EXECUTED 10f317: 5e pop %esi <== NOT EXECUTED 10f318: 5f pop %edi <== NOT EXECUTED 10f319: c9 leave <== NOT EXECUTED 10f31a: c3 ret <== NOT EXECUTED 10f31b: 90 nop <== NOT EXECUTED 10f31c: 8d 58 f8 lea -0x8(%eax),%ebx <== NOT EXECUTED 10f31f: 31 d2 xor %edx,%edx <== NOT EXECUTED 10f321: f7 77 10 divl 0x10(%edi) <== NOT EXECUTED 10f324: 29 d3 sub %edx,%ebx <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10f326: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 10f328: 77 e7 ja 10f311 <_Heap_Free+0x1d> <== NOT EXECUTED 10f32a: 39 de cmp %ebx,%esi <== NOT EXECUTED 10f32c: 72 e3 jb 10f311 <_Heap_Free+0x1d> <== NOT EXECUTED 10f32e: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10f331: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 10f334: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 10f337: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 10f33a: 01 d8 add %ebx,%eax <== NOT EXECUTED 10f33c: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10f33f: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10f341: 77 ce ja 10f311 <_Heap_Free+0x1d> <== NOT EXECUTED 10f343: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10f345: 72 ca jb 10f311 <_Heap_Free+0x1d> <== NOT EXECUTED 10f347: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 10f34a: 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 ) ) { 10f34d: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 10f350: 74 bf je 10f311 <_Heap_Free+0x1d> <== NOT EXECUTED 10f352: 83 e2 fe and $0xfffffffe,%edx <== NOT EXECUTED 10f355: 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 && 10f358: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10f35a: 76 74 jbe 10f3d0 <_Heap_Free+0xdc> <== NOT EXECUTED 10f35c: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10f35f: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10f362: 8b 44 02 04 mov 0x4(%edx,%eax,1),%eax <== NOT EXECUTED 10f366: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 10f369: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10f36c: 8a 45 e0 mov -0x20(%ebp),%al <== NOT EXECUTED 10f36f: 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 ) ) { 10f372: f6 45 dc 01 testb $0x1,-0x24(%ebp) <== NOT EXECUTED 10f376: 75 5c jne 10f3d4 <_Heap_Free+0xe0> <== NOT EXECUTED uint32_t const prev_size = the_block->prev_size; 10f378: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10f37a: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 10f37d: 29 d3 sub %edx,%ebx <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10f37f: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 10f381: 77 8e ja 10f311 <_Heap_Free+0x1d> <== NOT EXECUTED 10f383: 39 de cmp %ebx,%esi <== NOT EXECUTED 10f385: 72 8a jb 10f311 <_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) ) { 10f387: f6 43 04 01 testb $0x1,0x4(%ebx) <== NOT EXECUTED 10f38b: 74 84 je 10f311 <_Heap_Free+0x1d> <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } if ( next_is_free ) { /* coalesce both */ 10f38d: 84 c0 test %al,%al <== NOT EXECUTED 10f38f: 0f 84 a0 00 00 00 je 10f435 <_Heap_Free+0x141> <== NOT EXECUTED uint32_t const size = the_size + prev_size + next_size; 10f395: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10f398: 03 55 ec add -0x14(%ebp),%edx <== NOT EXECUTED 10f39b: 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 10f39e: 8b 75 e4 mov -0x1c(%ebp),%esi <== NOT EXECUTED 10f3a1: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED * @param[in] size is the amount of memory to allocate in bytes 10f3a4: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED * @param[in] alignment the required alignment 10f3a7: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10f3aa: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED _Heap_Block_remove( next_block ); stats->free_blocks -= 1; 10f3ad: ff 4f 38 decl 0x38(%edi) <== NOT EXECUTED prev_block->size = size | HEAP_PREV_USED; 10f3b0: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f3b2: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10f3b5: 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; 10f3b8: 89 14 13 mov %edx,(%ebx,%edx,1) <== NOT EXECUTED 10f3bb: 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; 10f3bc: ff 4f 40 decl 0x40(%edi) <== NOT EXECUTED stats->free_size += the_size; 10f3bf: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 10f3c2: 01 77 30 add %esi,0x30(%edi) <== NOT EXECUTED stats->frees += 1; 10f3c5: ff 47 50 incl 0x50(%edi) <== NOT EXECUTED 10f3c8: b0 01 mov $0x1,%al <== NOT EXECUTED 10f3ca: e9 44 ff ff ff jmp 10f313 <_Heap_Free+0x1f> <== NOT EXECUTED 10f3cf: 90 nop <== NOT EXECUTED _HAssert( FALSE ); return( FALSE ); } next_size = _Heap_Block_size( next_block ); next_is_free = next_block < the_heap->final && 10f3d0: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f3d2: eb 9e jmp 10f372 <_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 */ 10f3d4: 84 c0 test %al,%al <== NOT EXECUTED 10f3d6: 74 28 je 10f400 <_Heap_Free+0x10c> <== NOT EXECUTED uint32_t const size = the_size + next_size; 10f3d8: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10f3db: 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 */ 10f3de: 8b 75 e4 mov -0x1c(%ebp),%esi <== NOT EXECUTED 10f3e1: 8b 4e 08 mov 0x8(%esi),%ecx <== NOT EXECUTED bool _Protected_heap_Get_block_size( 10f3e4: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size 10f3e7: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED ); 10f3ea: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED 10f3ed: 89 58 08 mov %ebx,0x8(%eax) <== NOT EXECUTED 10f3f0: 89 59 0c mov %ebx,0xc(%ecx) <== NOT EXECUTED _Heap_Block_replace( next_block, the_block ); the_block->size = size | HEAP_PREV_USED; 10f3f3: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f3f5: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10f3f8: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block = _Heap_Block_at( the_block, size ); next_block->prev_size = size; 10f3fb: 89 14 13 mov %edx,(%ebx,%edx,1) <== NOT EXECUTED 10f3fe: eb bc jmp 10f3bc <_Heap_Free+0xc8> <== NOT EXECUTED bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ); 10f400: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED /** 10f403: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED * This routine returns the block of memory which begins 10f406: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10f409: 89 5f 08 mov %ebx,0x8(%edi) <== NOT EXECUTED 10f40c: 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; 10f40f: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10f412: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10f415: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block->size &= ~HEAP_PREV_USED; 10f418: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10f41b: 83 60 04 fe andl $0xfffffffe,0x4(%eax) <== NOT EXECUTED next_block->prev_size = the_size; 10f41f: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10f422: 89 10 mov %edx,(%eax) <== NOT EXECUTED stats->free_blocks += 1; 10f424: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 10f427: 40 inc %eax <== NOT EXECUTED 10f428: 89 47 38 mov %eax,0x38(%edi) <== NOT EXECUTED if ( stats->max_free_blocks < stats->free_blocks ) 10f42b: 3b 47 3c cmp 0x3c(%edi),%eax <== NOT EXECUTED 10f42e: 76 8c jbe 10f3bc <_Heap_Free+0xc8> <== NOT EXECUTED stats->max_free_blocks = stats->free_blocks; 10f430: 89 47 3c mov %eax,0x3c(%edi) <== NOT EXECUTED 10f433: eb 87 jmp 10f3bc <_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; 10f435: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 10f438: 03 55 f0 add -0x10(%ebp),%edx <== NOT EXECUTED prev_block->size = size | HEAP_PREV_USED; 10f43b: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f43d: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10f440: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED next_block->size &= ~HEAP_PREV_USED; 10f443: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10f446: 83 60 04 fe andl $0xfffffffe,0x4(%eax) <== NOT EXECUTED next_block->prev_size = size; 10f44a: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10f44c: e9 6b ff ff ff jmp 10f3bc <_Heap_Free+0xc8> <== NOT EXECUTED 00126940 <_Heap_Get_free_information>: void _Heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 126940: 55 push %ebp <== NOT EXECUTED 126941: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126943: 53 push %ebx <== NOT EXECUTED 126944: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 126947: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED Heap_Block *the_block; Heap_Block *const tail = _Heap_Tail(the_heap); info->number = 0; 12694a: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED info->largest = 0; 126950: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED info->total = 0; 126957: 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( 12695e: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED for(the_block = _Heap_First(the_heap); the_block != tail; 126961: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 126963: 74 1d je 126982 <_Heap_Get_free_information+0x42> <== NOT EXECUTED 126965: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 126968: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 12696b: 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++; 12696e: ff 01 incl (%ecx) <== NOT EXECUTED info->total += the_size; 126970: 01 41 08 add %eax,0x8(%ecx) <== NOT EXECUTED if ( info->largest < the_size ) 126973: 39 41 04 cmp %eax,0x4(%ecx) <== NOT EXECUTED 126976: 73 03 jae 12697b <_Heap_Get_free_information+0x3b> <== NOT EXECUTED info->largest = the_size; 126978: 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) 12697b: 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; 12697e: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 126980: 75 e6 jne 126968 <_Heap_Get_free_information+0x28> <== NOT EXECUTED info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 126982: 5b pop %ebx <== NOT EXECUTED 126983: c9 leave <== NOT EXECUTED 126984: c3 ret <== NOT EXECUTED 0012f734 <_Heap_Get_information>: Heap_Get_information_status _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 12f734: 55 push %ebp <== NOT EXECUTED 12f735: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f737: 56 push %esi <== NOT EXECUTED 12f738: 53 push %ebx <== NOT EXECUTED 12f739: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 12f73c: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED Heap_Block *the_block = the_heap->start; 12f73f: 8b 50 20 mov 0x20(%eax),%edx <== NOT EXECUTED Heap_Block *const end = the_heap->final; 12f742: 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; 12f745: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED the_info->Free.total = 0; 12f74b: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED the_info->Free.largest = 0; 12f752: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED the_info->Used.number = 0; 12f759: c7 41 0c 00 00 00 00 movl $0x0,0xc(%ecx) <== NOT EXECUTED the_info->Used.total = 0; 12f760: c7 41 14 00 00 00 00 movl $0x0,0x14(%ecx) <== NOT EXECUTED the_info->Used.largest = 0; 12f767: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx) <== NOT EXECUTED while ( the_block != end ) { 12f76e: 39 f2 cmp %esi,%edx <== NOT EXECUTED 12f770: 74 42 je 12f7b4 <_Heap_Get_information+0x80> <== NOT EXECUTED 12f772: 8b 5a 04 mov 0x4(%edx),%ebx <== NOT EXECUTED 12f775: eb 13 jmp 12f78a <_Heap_Get_information+0x56> <== NOT EXECUTED 12f777: 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++; 12f778: ff 41 0c incl 0xc(%ecx) <== NOT EXECUTED the_info->Used.total += the_size; 12f77b: 01 41 14 add %eax,0x14(%ecx) <== NOT EXECUTED if ( the_info->Used.largest < the_size ) 12f77e: 39 41 10 cmp %eax,0x10(%ecx) <== NOT EXECUTED 12f781: 73 03 jae 12f786 <_Heap_Get_information+0x52> <== NOT EXECUTED the_info->Used.largest = the_size; 12f783: 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 ) { 12f786: 39 d6 cmp %edx,%esi <== NOT EXECUTED 12f788: 74 2a je 12f7b4 <_Heap_Get_information+0x80> <== NOT EXECUTED 12f78a: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12f78c: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 12f78f: 01 c2 add %eax,%edx <== NOT EXECUTED 12f791: 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) ) { 12f794: f6 c3 01 test $0x1,%bl <== NOT EXECUTED 12f797: 75 df jne 12f778 <_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++; 12f799: ff 01 incl (%ecx) <== NOT EXECUTED the_info->Free.total += the_size; 12f79b: 01 41 08 add %eax,0x8(%ecx) <== NOT EXECUTED if ( the_info->Free.largest < the_size ) 12f79e: 39 41 04 cmp %eax,0x4(%ecx) <== NOT EXECUTED 12f7a1: 73 03 jae 12f7a6 <_Heap_Get_information+0x72> <== NOT EXECUTED the_info->Free.largest = the_size; 12f7a3: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED if ( the_size != next_block->prev_size ) 12f7a6: 39 02 cmp %eax,(%edx) <== NOT EXECUTED 12f7a8: 74 dc je 12f786 <_Heap_Get_information+0x52> <== NOT EXECUTED 12f7aa: 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; } 12f7af: 5b pop %ebx <== NOT EXECUTED 12f7b0: 5e pop %esi <== NOT EXECUTED 12f7b1: c9 leave <== NOT EXECUTED 12f7b2: c3 ret <== NOT EXECUTED 12f7b3: 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; 12f7b4: 83 41 14 08 addl $0x8,0x14(%ecx) <== NOT EXECUTED 12f7b8: 31 c0 xor %eax,%eax <== NOT EXECUTED return HEAP_GET_INFORMATION_SUCCESSFUL; } 12f7ba: 5b pop %ebx <== NOT EXECUTED 12f7bb: 5e pop %esi <== NOT EXECUTED 12f7bc: c9 leave <== NOT EXECUTED 12f7bd: c3 ret <== NOT EXECUTED 0010b2f4 <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 10b2f4: 55 push %ebp <== NOT EXECUTED 10b2f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b2f7: 57 push %edi <== NOT EXECUTED 10b2f8: 56 push %esi <== NOT EXECUTED 10b2f9: 53 push %ebx <== NOT EXECUTED 10b2fa: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b2fd: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b300: 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) 10b303: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b305: 0f 85 fd 00 00 00 jne 10b408 <_Heap_Initialize+0x114> <== NOT EXECUTED 10b30b: b1 04 mov $0x4,%cl <== NOT EXECUTED 10b30d: 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; 10b30f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10b312: 83 c3 08 add $0x8,%ebx <== NOT EXECUTED 10b315: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b317: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b319: f7 f1 div %ecx <== NOT EXECUTED 10b31b: 85 d2 test %edx,%edx <== NOT EXECUTED 10b31d: 74 05 je 10b324 <_Heap_Initialize+0x30> <== NOT EXECUTED 10b31f: 8d 1c 19 lea (%ecx,%ebx,1),%ebx <== NOT EXECUTED 10b322: 29 d3 sub %edx,%ebx <== NOT EXECUTED _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 10b324: 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 */ 10b327: 85 f6 test %esi,%esi <== NOT EXECUTED 10b329: 0f 85 cd 00 00 00 jne 10b3fc <_Heap_Initialize+0x108> <== NOT EXECUTED 10b32f: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 10b334: 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); 10b337: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b339: 2b 45 0c sub 0xc(%ebp),%eax <== NOT EXECUTED 10b33c: 83 c0 08 add $0x8,%eax <== NOT EXECUTED if ( size < overhead ) 10b33f: 3b 45 10 cmp 0x10(%ebp),%eax <== NOT EXECUTED 10b342: 0f 87 a8 00 00 00 ja 10b3f0 <_Heap_Initialize+0xfc> <== NOT EXECUTED return 0; /* Too small area for the heap */ the_size = size - overhead; 10b348: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10b34b: 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 10b34d: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b34f: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b351: f7 f1 div %ecx <== NOT EXECUTED _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 10b353: 29 d6 sub %edx,%esi <== NOT EXECUTED 10b355: 0f 84 95 00 00 00 je 10b3f0 <_Heap_Initialize+0xfc> <== NOT EXECUTED return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 10b35b: 89 4f 10 mov %ecx,0x10(%edi) <== NOT EXECUTED the_heap->begin = starting_address; 10b35e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b361: 89 47 18 mov %eax,0x18(%edi) <== NOT EXECUTED the_heap->end = starting_address + size; 10b364: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b367: 03 45 10 add 0x10(%ebp),%eax <== NOT EXECUTED 10b36a: 89 47 1c mov %eax,0x1c(%edi) <== NOT EXECUTED the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; 10b36d: 89 0b mov %ecx,(%ebx) <== NOT EXECUTED the_block->size = the_size | HEAP_PREV_USED; 10b36f: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b371: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 10b374: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED the_block->next = _Heap_Tail( the_heap ); 10b377: 89 7b 08 mov %edi,0x8(%ebx) <== NOT EXECUTED the_block->prev = _Heap_Head( the_heap ); 10b37a: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED _Heap_Head(the_heap)->next = the_block; 10b37d: 89 5f 08 mov %ebx,0x8(%edi) <== NOT EXECUTED _Heap_Tail(the_heap)->prev = the_block; 10b380: 89 5f 0c mov %ebx,0xc(%edi) <== NOT EXECUTED the_heap->start = the_block; 10b383: 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 10b386: 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 */ 10b389: 89 47 24 mov %eax,0x24(%edi) <== NOT EXECUTED the_block->prev_size = the_size; /* Previous block is free */ 10b38c: 89 30 mov %esi,(%eax) <== NOT EXECUTED the_block->size = page_size; 10b38e: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED stats->size = size; 10b391: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10b394: 89 47 2c mov %eax,0x2c(%edi) <== NOT EXECUTED stats->free_size = the_size; 10b397: 89 77 30 mov %esi,0x30(%edi) <== NOT EXECUTED stats->min_free_size = the_size; 10b39a: 89 77 34 mov %esi,0x34(%edi) <== NOT EXECUTED stats->free_blocks = 1; 10b39d: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi) <== NOT EXECUTED stats->max_free_blocks = 1; 10b3a4: c7 47 3c 01 00 00 00 movl $0x1,0x3c(%edi) <== NOT EXECUTED stats->used_blocks = 0; 10b3ab: c7 47 40 00 00 00 00 movl $0x0,0x40(%edi) <== NOT EXECUTED stats->max_search = 0; 10b3b2: c7 47 44 00 00 00 00 movl $0x0,0x44(%edi) <== NOT EXECUTED stats->allocs = 0; 10b3b9: c7 47 48 00 00 00 00 movl $0x0,0x48(%edi) <== NOT EXECUTED stats->searches = 0; 10b3c0: c7 47 4c 00 00 00 00 movl $0x0,0x4c(%edi) <== NOT EXECUTED stats->frees = 0; 10b3c7: c7 47 50 00 00 00 00 movl $0x0,0x50(%edi) <== NOT EXECUTED stats->resizes = 0; 10b3ce: c7 47 54 00 00 00 00 movl $0x0,0x54(%edi) <== NOT EXECUTED stats->instance = instance++; 10b3d5: a1 60 e7 11 00 mov 0x11e760,%eax <== NOT EXECUTED 10b3da: 89 47 28 mov %eax,0x28(%edi) <== NOT EXECUTED 10b3dd: 40 inc %eax <== NOT EXECUTED 10b3de: a3 60 e7 11 00 mov %eax,0x11e760 <== NOT EXECUTED return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 10b3e3: 8d 46 fc lea -0x4(%esi),%eax <== NOT EXECUTED } 10b3e6: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10b3e9: 5b pop %ebx <== NOT EXECUTED 10b3ea: 5e pop %esi <== NOT EXECUTED 10b3eb: 5f pop %edi <== NOT EXECUTED 10b3ec: c9 leave <== NOT EXECUTED 10b3ed: c3 ret <== NOT EXECUTED 10b3ee: 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 ); 10b3f0: 31 c0 xor %eax,%eax <== NOT EXECUTED } 10b3f2: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10b3f5: 5b pop %ebx <== NOT EXECUTED 10b3f6: 5e pop %esi <== NOT EXECUTED 10b3f7: 5f pop %edi <== NOT EXECUTED 10b3f8: c9 leave <== NOT EXECUTED 10b3f9: c3 ret <== NOT EXECUTED 10b3fa: 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 */ 10b3fc: 8d 41 10 lea 0x10(%ecx),%eax <== NOT EXECUTED 10b3ff: 29 f0 sub %esi,%eax <== NOT EXECUTED 10b401: e9 2e ff ff ff jmp 10b334 <_Heap_Initialize+0x40> <== NOT EXECUTED 10b406: 66 90 xchg %ax,%ax <== NOT EXECUTED 10b408: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b40a: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 10b40d: 74 05 je 10b414 <_Heap_Initialize+0x120> <== NOT EXECUTED 10b40f: 83 c1 04 add $0x4,%ecx <== NOT EXECUTED 10b412: 29 c1 sub %eax,%ecx <== NOT EXECUTED 10b414: b8 10 00 00 00 mov $0x10,%eax <== NOT EXECUTED 10b419: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b41b: f7 f1 div %ecx <== NOT EXECUTED 10b41d: 89 d6 mov %edx,%esi <== NOT EXECUTED 10b41f: e9 eb fe ff ff jmp 10b30f <_Heap_Initialize+0x1b> <== NOT EXECUTED 00116a58 <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 116a58: 55 push %ebp <== NOT EXECUTED 116a59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116a5b: 57 push %edi <== NOT EXECUTED 116a5c: 56 push %esi <== NOT EXECUTED 116a5d: 53 push %ebx <== NOT EXECUTED 116a5e: 83 ec 3c sub $0x3c,%esp <== NOT EXECUTED 116a61: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 116a64: 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; 116a67: 8b 46 14 mov 0x14(%esi),%eax <== NOT EXECUTED 116a6a: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED uint32_t const page_size = the_heap->page_size; 116a6d: 8b 56 10 mov 0x10(%esi),%edx <== NOT EXECUTED 116a70: 89 55 e4 mov %edx,-0x1c(%ebp) <== NOT EXECUTED *old_mem_size = 0; 116a73: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 116a76: c7 07 00 00 00 00 movl $0x0,(%edi) <== NOT EXECUTED *avail_mem_size = 0; 116a7c: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 116a7f: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 116a85: 8d 59 f8 lea -0x8(%ecx),%ebx <== NOT EXECUTED 116a88: 89 c8 mov %ecx,%eax <== NOT EXECUTED 116a8a: 31 d2 xor %edx,%edx <== NOT EXECUTED 116a8c: f7 76 10 divl 0x10(%esi) <== NOT EXECUTED 116a8f: 29 d3 sub %edx,%ebx <== NOT EXECUTED 116a91: 8b 56 24 mov 0x24(%esi),%edx <== NOT EXECUTED 116a94: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 116a97: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 116a99: 72 04 jb 116a9f <_Heap_Resize_block+0x47> <== NOT EXECUTED 116a9b: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 116a9d: 76 0d jbe 116aac <_Heap_Resize_block+0x54> <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 116a9f: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED } 116aa4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116aa7: 5b pop %ebx <== NOT EXECUTED 116aa8: 5e pop %esi <== NOT EXECUTED 116aa9: 5f pop %edi <== NOT EXECUTED 116aaa: c9 leave <== NOT EXECUTED 116aab: 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; 116aac: 8b 7b 04 mov 0x4(%ebx),%edi <== NOT EXECUTED 116aaf: 89 7d cc mov %edi,-0x34(%ebp) <== NOT EXECUTED 116ab2: 83 e7 fe and $0xfffffffe,%edi <== NOT EXECUTED 116ab5: 89 7d d8 mov %edi,-0x28(%ebp) <== NOT EXECUTED 116ab8: 01 df add %ebx,%edi <== NOT EXECUTED 116aba: 89 7d c0 mov %edi,-0x40(%ebp) <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 116abd: 39 f8 cmp %edi,%eax <== NOT EXECUTED 116abf: 77 de ja 116a9f <_Heap_Resize_block+0x47> <== NOT EXECUTED 116ac1: 39 fa cmp %edi,%edx <== NOT EXECUTED 116ac3: 72 da jb 116a9f <_Heap_Resize_block+0x47> <== NOT EXECUTED 116ac5: 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) || 116ac8: a8 01 test $0x1,%al <== NOT EXECUTED 116aca: 74 d3 je 116a9f <_Heap_Resize_block+0x47> <== NOT EXECUTED 116acc: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 116acf: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 116ad2: 01 f8 add %edi,%eax <== NOT EXECUTED 116ad4: 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) || 116ad7: 39 fa cmp %edi,%edx <== NOT EXECUTED 116ad9: 0f 84 11 01 00 00 je 116bf0 <_Heap_Resize_block+0x198> <== NOT EXECUTED 116adf: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 116ae2: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 116ae5: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 116ae8: 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; 116aeb: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED 116aee: 83 e7 01 and $0x1,%edi <== NOT EXECUTED 116af1: 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) 116af4: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 116af7: 29 c8 sub %ecx,%eax <== NOT EXECUTED 116af9: 83 c0 04 add $0x4,%eax <== NOT EXECUTED + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 116afc: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 116aff: 89 02 mov %eax,(%edx) <== NOT EXECUTED if (size > old_user_size) { 116b01: 3b 45 10 cmp 0x10(%ebp),%eax <== NOT EXECUTED 116b04: 73 3a jae 116b40 <_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 */ 116b06: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 116b0a: 75 29 jne 116b35 <_Heap_Resize_block+0xdd> <== NOT EXECUTED return HEAP_RESIZE_UNSATISFIED; else { uint32_t add_block_size = size - old_user_size; 116b0c: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 116b0f: 29 c1 sub %eax,%ecx <== 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 116b11: 89 c8 mov %ecx,%eax <== NOT EXECUTED 116b13: 31 d2 xor %edx,%edx <== NOT EXECUTED 116b15: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED */ 116b18: 85 d2 test %edx,%edx <== NOT EXECUTED 116b1a: 74 05 je 116b21 <_Heap_Resize_block+0xc9> <== NOT EXECUTED 116b1c: 03 4d e4 add -0x1c(%ebp),%ecx <== NOT EXECUTED 116b1f: 29 d1 sub %edx,%ecx <== NOT EXECUTED 116b21: 89 c8 mov %ecx,%eax <== NOT EXECUTED 116b23: 3b 4d e0 cmp -0x20(%ebp),%ecx <== NOT EXECUTED 116b26: 0f 82 a0 00 00 00 jb 116bcc <_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) 116b2c: 39 45 d0 cmp %eax,-0x30(%ebp) <== NOT EXECUTED 116b2f: 0f 83 9f 00 00 00 jae 116bd4 <_Heap_Resize_block+0x17c> <== NOT EXECUTED } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 116b35: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 116b3a: e9 65 ff ff ff jmp 116aa4 <_Heap_Resize_block+0x4c> <== NOT EXECUTED 116b3f: 90 nop <== NOT EXECUTED --stats->used_blocks; } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 116b40: 89 c1 mov %eax,%ecx <== NOT EXECUTED 116b42: 2b 4d 10 sub 0x10(%ebp),%ecx <== NOT EXECUTED * * @return free block information filled in. */ bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info 116b45: 89 c8 mov %ecx,%eax <== NOT EXECUTED 116b47: 31 d2 xor %edx,%edx <== NOT EXECUTED 116b49: f7 75 e4 divl -0x1c(%ebp) <== NOT EXECUTED _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 116b4c: 29 d1 sub %edx,%ecx <== NOT EXECUTED 116b4e: 89 4d e8 mov %ecx,-0x18(%ebp) <== NOT EXECUTED 116b51: 74 69 je 116bbc <_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; 116b53: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 116b56: 29 ca sub %ecx,%edx <== NOT EXECUTED 116b58: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED if (new_block_size < min_block_size) { 116b5b: 39 55 e0 cmp %edx,-0x20(%ebp) <== NOT EXECUTED 116b5e: 76 0d jbe 116b6d <_Heap_Resize_block+0x115> <== NOT EXECUTED uint32_t delta = min_block_size - new_block_size; 116b60: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 116b63: 29 d0 sub %edx,%eax <== NOT EXECUTED _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 116b65: 29 45 e8 sub %eax,-0x18(%ebp) <== NOT EXECUTED 116b68: 74 52 je 116bbc <_Heap_Resize_block+0x164> <== NOT EXECUTED ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; } new_block_size += delta; 116b6a: 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) { 116b6d: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 116b71: 0f 85 85 00 00 00 jne 116bfc <_Heap_Resize_block+0x1a4> <== NOT EXECUTED 116b77: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 116b7a: 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; 116b7d: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 116b80: 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; 116b83: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 116b86: 09 c7 or %eax,%edi <== NOT EXECUTED 116b88: 89 7b 04 mov %edi,0x4(%ebx) <== NOT EXECUTED new_next_block->size = new_next_block_size | HEAP_PREV_USED; 116b8b: 89 c8 mov %ecx,%eax <== NOT EXECUTED 116b8d: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 116b90: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED next_next_block->prev_size = new_next_block_size; 116b93: 8b 7d d4 mov -0x2c(%ebp),%edi <== NOT EXECUTED 116b96: 89 0f mov %ecx,(%edi) <== 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 */ 116b98: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 116b9b: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED bool _Protected_heap_Get_block_size( 116b9e: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size 116ba1: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED ); 116ba4: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 116ba7: 89 50 08 mov %edx,0x8(%eax) <== NOT EXECUTED 116baa: 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; 116bad: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 116bb0: 01 46 30 add %eax,0x30(%esi) <== NOT EXECUTED *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 116bb3: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED 116bb6: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 116bb9: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 116bbb: 90 nop <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; } } } ++stats->resizes; 116bbc: ff 46 54 incl 0x54(%esi) <== NOT EXECUTED 116bbf: 31 c0 xor %eax,%eax <== NOT EXECUTED return HEAP_RESIZE_SUCCESSFUL; } 116bc1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116bc4: 5b pop %ebx <== NOT EXECUTED 116bc5: 5e pop %esi <== NOT EXECUTED 116bc6: 5f pop %edi <== NOT EXECUTED 116bc7: c9 leave <== NOT EXECUTED 116bc8: c3 ret <== NOT EXECUTED 116bc9: 8d 76 00 lea 0x0(%esi),%esi <== 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 */ 116bcc: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 116bcf: e9 58 ff ff ff jmp 116b2c <_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 = 116bd4: 52 push %edx <== NOT EXECUTED 116bd5: 50 push %eax <== NOT EXECUTED 116bd6: ff 75 c0 pushl -0x40(%ebp) <== NOT EXECUTED 116bd9: 56 push %esi <== NOT EXECUTED 116bda: e8 79 48 ff ff call 10b458 <_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; 116bdf: 03 45 d8 add -0x28(%ebp),%eax <== NOT EXECUTED 116be2: 0b 45 dc or -0x24(%ebp),%eax <== NOT EXECUTED 116be5: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED --stats->used_blocks; 116be8: ff 4e 40 decl 0x40(%esi) <== NOT EXECUTED 116beb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116bee: eb cc jmp 116bbc <_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) || 116bf0: c6 45 f3 01 movb $0x1,-0xd(%ebp) <== NOT EXECUTED 116bf4: e9 f2 fe ff ff jmp 116aeb <_Heap_Resize_block+0x93> <== NOT EXECUTED 116bf9: 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) { 116bfc: 8b 7d e8 mov -0x18(%ebp),%edi <== NOT EXECUTED 116bff: 39 7d e0 cmp %edi,-0x20(%ebp) <== NOT EXECUTED 116c02: 77 b8 ja 116bbc <_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; 116c04: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 116c07: 09 45 dc or %eax,-0x24(%ebp) <== NOT EXECUTED 116c0a: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 116c0d: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 116c10: 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; 116c13: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 116c16: 83 ca 01 or $0x1,%edx <== NOT EXECUTED 116c19: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 116c1c: ff 46 40 incl 0x40(%esi) <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 116c1f: ff 4e 50 decl 0x50(%esi) <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 116c22: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 116c25: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 116c28: 50 push %eax <== NOT EXECUTED 116c29: 56 push %esi <== NOT EXECUTED 116c2a: e8 c5 86 ff ff call 10f2f4 <_Heap_Free> <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 116c2f: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 116c32: 83 e8 04 sub $0x4,%eax <== NOT EXECUTED 116c35: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 116c38: 89 02 mov %eax,(%edx) <== NOT EXECUTED 116c3a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116c3d: e9 7a ff ff ff jmp 116bbc <_Heap_Resize_block+0x164> <== NOT EXECUTED 00116c44 <_Heap_Size_of_user_area>: bool _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 116c44: 55 push %ebp <== NOT EXECUTED 116c45: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116c47: 57 push %edi <== NOT EXECUTED 116c48: 56 push %esi <== NOT EXECUTED 116c49: 53 push %ebx <== NOT EXECUTED 116c4a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116c4d: 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( 116c50: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 116c53: 8b 70 24 mov 0x24(%eax),%esi <== NOT EXECUTED 116c56: 8b 48 20 mov 0x20(%eax),%ecx <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 116c59: 39 f9 cmp %edi,%ecx <== NOT EXECUTED 116c5b: 77 04 ja 116c61 <_Heap_Size_of_user_area+0x1d> <== NOT EXECUTED 116c5d: 39 fe cmp %edi,%esi <== NOT EXECUTED 116c5f: 73 0b jae 116c6c <_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 ); 116c61: 31 c0 xor %eax,%eax <== NOT EXECUTED } 116c63: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 116c66: 5b pop %ebx <== NOT EXECUTED 116c67: 5e pop %esi <== NOT EXECUTED 116c68: 5f pop %edi <== NOT EXECUTED 116c69: c9 leave <== NOT EXECUTED 116c6a: c3 ret <== NOT EXECUTED 116c6b: 90 nop <== NOT EXECUTED 116c6c: 8d 57 f8 lea -0x8(%edi),%edx <== NOT EXECUTED 116c6f: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 116c72: 89 f8 mov %edi,%eax <== NOT EXECUTED 116c74: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 116c77: 31 d2 xor %edx,%edx <== NOT EXECUTED 116c79: f7 73 10 divl 0x10(%ebx) <== NOT EXECUTED 116c7c: 29 55 e8 sub %edx,-0x18(%ebp) <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 116c7f: 3b 4d e8 cmp -0x18(%ebp),%ecx <== NOT EXECUTED 116c82: 77 dd ja 116c61 <_Heap_Size_of_user_area+0x1d> <== NOT EXECUTED 116c84: 3b 75 e8 cmp -0x18(%ebp),%esi <== NOT EXECUTED 116c87: 72 d8 jb 116c61 <_Heap_Size_of_user_area+0x1d> <== NOT EXECUTED 116c89: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 116c8c: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 116c8f: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 116c92: 01 d0 add %edx,%eax <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 116c94: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 116c96: 77 c9 ja 116c61 <_Heap_Size_of_user_area+0x1d> <== NOT EXECUTED 116c98: 39 c6 cmp %eax,%esi <== NOT EXECUTED 116c9a: 72 c5 jb 116c61 <_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 ( 116c9c: f6 40 04 01 testb $0x1,0x4(%eax) <== NOT EXECUTED 116ca0: 74 bf je 116c61 <_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 ) 116ca2: 29 f8 sub %edi,%eax <== NOT EXECUTED 116ca4: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 116ca7: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 116caa: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 116cac: b0 01 mov $0x1,%al <== NOT EXECUTED 116cae: eb b3 jmp 116c63 <_Heap_Size_of_user_area+0x1f> <== NOT EXECUTED 001115dc <_Heap_Walk>: bool _Heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 1115dc: 55 push %ebp <== NOT EXECUTED 1115dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1115df: 57 push %edi <== NOT EXECUTED 1115e0: 56 push %esi <== NOT EXECUTED 1115e1: 53 push %ebx <== NOT EXECUTED 1115e2: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1115e5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED Heap_Block *the_block = the_heap->start; 1115e8: 8b 7e 20 mov 0x20(%esi),%edi <== NOT EXECUTED Heap_Block *const end = the_heap->final; 1115eb: 8b 46 24 mov 0x24(%esi),%eax <== NOT EXECUTED 1115ee: 89 45 e4 mov %eax,-0x1c(%ebp) <== NOT EXECUTED /* if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) 1115f1: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1115f4: 85 c0 test %eax,%eax <== NOT EXECUTED 1115f6: 0f 88 67 02 00 00 js 111863 <_Heap_Walk+0x287> <== NOT EXECUTED /* * Handle the 1st block */ if (!_Heap_Is_prev_used(the_block)) { 1115fc: f6 47 04 01 testb $0x1,0x4(%edi) <== NOT EXECUTED 111600: 0f 84 3e 02 00 00 je 111844 <_Heap_Walk+0x268> <== NOT EXECUTED 111606: 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) { 11160d: 8b 07 mov (%edi),%eax <== NOT EXECUTED 11160f: 3b 46 10 cmp 0x10(%esi),%eax <== NOT EXECUTED 111612: 74 1a je 11162e <_Heap_Walk+0x52> <== NOT EXECUTED printk("PASS: %d !prev_size of 1st block isn't page_size\n", source); 111614: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111617: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11161a: 68 e8 ca 11 00 push $0x11cae8 <== NOT EXECUTED 11161f: e8 5c 7d ff ff call 109380 <== NOT EXECUTED 111624: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 11162b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } while ( the_block != end ) { 11162e: 3b 7d e4 cmp -0x1c(%ebp),%edi <== NOT EXECUTED 111631: 0f 84 37 02 00 00 je 11186e <_Heap_Walk+0x292> <== NOT EXECUTED 111637: 8b 57 04 mov 0x4(%edi),%edx <== NOT EXECUTED 11163a: 89 d3 mov %edx,%ebx <== NOT EXECUTED 11163c: 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 11163f: 8d 04 1f lea (%edi,%ebx,1),%eax <== NOT EXECUTED 111642: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 111645: 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 ); 111648: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 11164b: 39 4e 20 cmp %ecx,0x20(%esi) <== NOT EXECUTED 11164e: 0f 87 14 01 00 00 ja 111768 <_Heap_Walk+0x18c> <== NOT EXECUTED 111654: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 111656: 0f 87 0c 01 00 00 ja 111768 <_Heap_Walk+0x18c> <== NOT EXECUTED 11165c: 83 e2 01 and $0x1,%edx <== NOT EXECUTED 11165f: 88 55 f3 mov %dl,-0xd(%ebp) <== NOT EXECUTED 111662: 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)) { 111664: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 111667: f6 41 04 01 testb $0x1,0x4(%ecx) <== NOT EXECUTED 11166b: 0f 85 53 01 00 00 jne 1117c4 <_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) { 111671: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 111674: 39 18 cmp %ebx,(%eax) <== NOT EXECUTED 111676: 74 1a je 111692 <_Heap_Walk+0xb6> <== NOT EXECUTED if (do_dump) printk("\n"); printk("PASS: %d !front and back sizes don't match", source); 111678: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11167b: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11167e: 68 40 cb 11 00 push $0x11cb40 <== NOT EXECUTED 111683: e8 f8 7c ff ff call 109380 <== NOT EXECUTED 111688: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 11168f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } if (!prev_used) { 111692: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 111696: 75 25 jne 1116bd <_Heap_Walk+0xe1> <== NOT EXECUTED if (do_dump || error) printk("\n"); 111698: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 11169b: 85 c0 test %eax,%eax <== NOT EXECUTED 11169d: 0f 85 81 01 00 00 jne 111824 <_Heap_Walk+0x248> <== NOT EXECUTED printk("PASS: %d !two consecutive blocks are free", source); 1116a3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1116a6: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1116a9: 68 6c cb 11 00 push $0x11cb6c <== NOT EXECUTED 1116ae: e8 cd 7c ff ff call 109380 <== NOT EXECUTED 1116b3: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 1116ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { return ( the_thread == _Thread_Heir ); } /** 1116bd: 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) 1116c0: 39 c7 cmp %eax,%edi <== NOT EXECUTED 1116c2: 75 13 jne 1116d7 <_Heap_Walk+0xfb> <== NOT EXECUTED 1116c4: e9 fb 00 00 00 jmp 1117c4 <_Heap_Walk+0x1e8> <== NOT EXECUTED 1116c9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED block = block->next; 1116cc: 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) 1116cf: 39 f8 cmp %edi,%eax <== NOT EXECUTED 1116d1: 0f 84 ed 00 00 00 je 1117c4 <_Heap_Walk+0x1e8> <== NOT EXECUTED 1116d7: 39 c6 cmp %eax,%esi <== NOT EXECUTED 1116d9: 75 f1 jne 1116cc <_Heap_Walk+0xf0> <== NOT EXECUTED block = block->next; if(block != the_block) { if (do_dump || error) printk("\n"); 1116db: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 1116de: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1116e0: 74 10 je 1116f2 <_Heap_Walk+0x116> <== NOT EXECUTED 1116e2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1116e5: 68 e7 a6 11 00 push $0x11a6e7 <== NOT EXECUTED 1116ea: e8 91 7c ff ff call 109380 <== NOT EXECUTED 1116ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED printk("PASS: %d !the_block not in the free list", source); 1116f2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1116f5: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1116f8: 68 98 cb 11 00 push $0x11cb98 <== NOT EXECUTED 1116fd: e8 7e 7c ff ff call 109380 <== NOT EXECUTED 111702: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111709: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } } } if (do_dump || error) printk("\n"); 11170c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11170f: 68 e7 a6 11 00 push $0x11a6e7 <== NOT EXECUTED 111714: e8 67 7c ff ff call 109380 <== NOT EXECUTED 111719: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (the_size < the_heap->min_block_size) { 11171c: 3b 5e 14 cmp 0x14(%esi),%ebx <== NOT EXECUTED 11171f: 0f 82 b3 00 00 00 jb 1117d8 <_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)) { 111725: 89 d8 mov %ebx,%eax <== NOT EXECUTED 111727: 31 d2 xor %edx,%edx <== NOT EXECUTED 111729: f7 76 10 divl 0x10(%esi) <== NOT EXECUTED 11172c: 85 d2 test %edx,%edx <== NOT EXECUTED 11172e: 0f 85 d8 00 00 00 jne 11180c <_Heap_Walk+0x230> <== NOT EXECUTED printk("PASS: %d !block size is misaligned\n", source); error = 1; } if (++passes > (do_dump ? 10 : 0) && error) 111734: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 111737: 85 c0 test %eax,%eax <== NOT EXECUTED 111739: 75 41 jne 11177c <_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 ) { 11173b: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 11173e: 39 4d e4 cmp %ecx,-0x1c(%ebp) <== NOT EXECUTED 111741: 0f 84 27 01 00 00 je 11186e <_Heap_Walk+0x292> <== NOT EXECUTED 111747: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 11174a: 8b 48 04 mov 0x4(%eax),%ecx <== NOT EXECUTED 11174d: 89 cb mov %ecx,%ebx <== NOT EXECUTED 11174f: 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 ); 111752: 01 d8 add %ebx,%eax <== NOT EXECUTED 111754: 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 ); 111757: 3b 46 20 cmp 0x20(%esi),%eax <== NOT EXECUTED 11175a: 0f 83 90 00 00 00 jae 1117f0 <_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)) { 111760: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 111763: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 111766: 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); 111768: 50 push %eax <== NOT EXECUTED 111769: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 11176c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11176f: 68 1c cb 11 00 push $0x11cb1c <== NOT EXECUTED 111774: e8 07 7c ff ff call 109380 <== NOT EXECUTED 111779: 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", 11177c: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 11177f: 57 push %edi <== NOT EXECUTED 111780: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111783: 68 0c cc 11 00 push $0x11cc0c <== NOT EXECUTED 111788: e8 f3 7b ff ff call 109380 <== NOT EXECUTED 11178d: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111794: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111797: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 11179a: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED source, the_block, end); error = 1; } if (_Heap_Block_size(the_block) != the_heap->page_size) { 11179d: 8b 56 10 mov 0x10(%esi),%edx <== NOT EXECUTED 1117a0: 39 c2 cmp %eax,%edx <== NOT EXECUTED 1117a2: 0f 84 91 00 00 00 je 111839 <_Heap_Walk+0x25d> <== NOT EXECUTED printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source, 1117a8: 52 push %edx <== NOT EXECUTED 1117a9: 50 push %eax <== NOT EXECUTED 1117aa: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1117ad: 68 48 cc 11 00 push $0x11cc48 <== NOT EXECUTED 1117b2: e8 c9 7b ff ff call 109380 <== NOT EXECUTED 1117b7: b0 01 mov $0x1,%al <== NOT EXECUTED 1117b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if(do_dump && error) _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 ); return error; } 1117bc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1117bf: 5b pop %ebx <== NOT EXECUTED 1117c0: 5e pop %esi <== NOT EXECUTED 1117c1: 5f pop %edi <== NOT EXECUTED 1117c2: c9 leave <== NOT EXECUTED 1117c3: c3 ret <== NOT EXECUTED error = 1; } } } if (do_dump || error) printk("\n"); 1117c4: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 1117c7: 85 d2 test %edx,%edx <== NOT EXECUTED 1117c9: 0f 85 3d ff ff ff jne 11170c <_Heap_Walk+0x130> <== NOT EXECUTED if (the_size < the_heap->min_block_size) { 1117cf: 3b 5e 14 cmp 0x14(%esi),%ebx <== NOT EXECUTED 1117d2: 0f 83 4d ff ff ff jae 111725 <_Heap_Walk+0x149> <== NOT EXECUTED printk("PASS: %d !block size is too small\n", source); 1117d8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1117db: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1117de: 68 c4 cb 11 00 push $0x11cbc4 <== NOT EXECUTED 1117e3: e8 98 7b ff ff call 109380 <== NOT EXECUTED 1117e8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1117eb: eb 8f jmp 11177c <_Heap_Walk+0x1a0> <== NOT EXECUTED 1117ed: 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 ); 1117f0: 39 d0 cmp %edx,%eax <== NOT EXECUTED 1117f2: 0f 87 68 ff ff ff ja 111760 <_Heap_Walk+0x184> <== NOT EXECUTED 1117f8: 83 e1 01 and $0x1,%ecx <== NOT EXECUTED 1117fb: 88 4d f3 mov %cl,-0xd(%ebp) <== NOT EXECUTED 1117fe: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 111801: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 111804: e9 5b fe ff ff jmp 111664 <_Heap_Walk+0x88> <== NOT EXECUTED 111809: 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); 11180c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11180f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111812: 68 e8 cb 11 00 push $0x11cbe8 <== NOT EXECUTED 111817: e8 64 7b ff ff call 109380 <== NOT EXECUTED 11181c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11181f: e9 58 ff ff ff jmp 11177c <_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"); 111824: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111827: 68 e7 a6 11 00 push $0x11a6e7 <== NOT EXECUTED 11182c: e8 4f 7b ff ff call 109380 <== NOT EXECUTED 111831: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111834: e9 6a fe ff ff jmp 1116a3 <_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) { 111839: 8a 45 e8 mov -0x18(%ebp),%al <== NOT EXECUTED if(do_dump && error) _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 ); return error; } 11183c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11183f: 5b pop %ebx <== NOT EXECUTED 111840: 5e pop %esi <== NOT EXECUTED 111841: 5f pop %edi <== NOT EXECUTED 111842: c9 leave <== NOT EXECUTED 111843: 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); 111844: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111847: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11184a: 68 b0 ca 11 00 push $0x11cab0 <== NOT EXECUTED 11184f: e8 2c 7b ff ff call 109380 <== NOT EXECUTED 111854: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 11185b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11185e: e9 aa fd ff ff jmp 11160d <_Heap_Walk+0x31> <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) source = the_heap->stats.instance; 111863: 8b 4e 28 mov 0x28(%esi),%ecx <== NOT EXECUTED 111866: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED 111869: e9 8e fd ff ff jmp 1115fc <_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, 11186e: 8b 7d e4 mov -0x1c(%ebp),%edi <== NOT EXECUTED 111871: e9 21 ff ff ff jmp 111797 <_Heap_Walk+0x1bb> <== NOT EXECUTED 0010aa54 <_IO_Initialize_all_drivers>: * * Output Parameters: NONE */ void _IO_Initialize_all_drivers( void ) { 10aa54: 55 push %ebp <== NOT EXECUTED 10aa55: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa57: 53 push %ebx <== NOT EXECUTED 10aa58: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10aa5b: 8b 15 a0 ed 11 00 mov 0x11eda0,%edx <== NOT EXECUTED 10aa61: 85 d2 test %edx,%edx <== NOT EXECUTED 10aa63: 74 1a je 10aa7f <_IO_Initialize_all_drivers+0x2b> <== NOT EXECUTED 10aa65: 31 db xor %ebx,%ebx <== NOT EXECUTED 10aa67: 90 nop <== NOT EXECUTED (void) rtems_io_initialize( major, 0, NULL ); 10aa68: 50 push %eax <== NOT EXECUTED 10aa69: 6a 00 push $0x0 <== NOT EXECUTED 10aa6b: 6a 00 push $0x0 <== NOT EXECUTED 10aa6d: 53 push %ebx <== NOT EXECUTED 10aa6e: e8 29 45 00 00 call 10ef9c <== NOT EXECUTED void _IO_Initialize_all_drivers( void ) { rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10aa73: 43 inc %ebx <== NOT EXECUTED 10aa74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aa77: 39 1d a0 ed 11 00 cmp %ebx,0x11eda0 <== NOT EXECUTED 10aa7d: 77 e9 ja 10aa68 <_IO_Initialize_all_drivers+0x14> <== NOT EXECUTED (void) rtems_io_initialize( major, 0, NULL ); } 10aa7f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aa82: c9 leave <== NOT EXECUTED 10aa83: c3 ret <== NOT EXECUTED 0010aa84 <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 10aa84: 55 push %ebp <== NOT EXECUTED 10aa85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa87: 57 push %edi <== NOT EXECUTED 10aa88: 56 push %esi <== NOT EXECUTED 10aa89: 53 push %ebx <== NOT EXECUTED 10aa8a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aa8d: 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 ) 10aa90: 3b 75 0c cmp 0xc(%ebp),%esi <== NOT EXECUTED 10aa93: 76 5b jbe 10aaf0 <_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 *) 10aa95: 8d 04 76 lea (%esi,%esi,2),%eax <== NOT EXECUTED 10aa98: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx <== NOT EXECUTED 10aa9f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10aaa2: 53 push %ebx <== NOT EXECUTED 10aaa3: e8 4c 29 00 00 call 10d3f4 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10aaa8: 89 c7 mov %eax,%edi <== NOT EXECUTED 10aaaa: a3 a4 ed 11 00 mov %eax,0x11eda4 <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 10aaaf: 89 35 a0 ed 11 00 mov %esi,0x11eda0 <== NOT EXECUTED memset( 10aab5: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aab7: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10aab9: 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++ ) 10aabb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10aabe: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10aac1: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10aac3: 74 23 je 10aae8 <_IO_Manager_initialization+0x64> <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; 10aac5: 8b 1d a4 ed 11 00 mov 0x11eda4,%ebx <== NOT EXECUTED 10aacb: 31 d2 xor %edx,%edx <== NOT EXECUTED 10aacd: 31 c0 xor %eax,%eax <== NOT EXECUTED 10aacf: 90 nop <== NOT EXECUTED 10aad0: 8d 3c 03 lea (%ebx,%eax,1),%edi <== NOT EXECUTED 10aad3: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10aad6: 01 c6 add %eax,%esi <== NOT EXECUTED 10aad8: b9 06 00 00 00 mov $0x6,%ecx <== NOT EXECUTED 10aadd: 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++ ) 10aadf: 42 inc %edx <== NOT EXECUTED 10aae0: 83 c0 18 add $0x18,%eax <== NOT EXECUTED 10aae3: 39 55 0c cmp %edx,0xc(%ebp) <== NOT EXECUTED 10aae6: 77 e8 ja 10aad0 <_IO_Manager_initialization+0x4c> <== NOT EXECUTED _IO_Driver_address_table[index] = driver_table[index]; number_of_drivers = drivers_in_table; } 10aae8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aaeb: 5b pop %ebx <== NOT EXECUTED 10aaec: 5e pop %esi <== NOT EXECUTED 10aaed: 5f pop %edi <== NOT EXECUTED 10aaee: c9 leave <== NOT EXECUTED 10aaef: 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; 10aaf0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10aaf3: a3 a4 ed 11 00 mov %eax,0x11eda4 <== NOT EXECUTED _IO_Number_of_drivers = number_of_drivers; 10aaf8: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10aafb: 89 0d a0 ed 11 00 mov %ecx,0x11eda0 <== NOT EXECUTED ); for ( index = 0 ; index < drivers_in_table ; index++ ) _IO_Driver_address_table[index] = driver_table[index]; number_of_drivers = drivers_in_table; } 10ab01: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ab04: 5b pop %ebx <== NOT EXECUTED 10ab05: 5e pop %esi <== NOT EXECUTED 10ab06: 5f pop %edi <== NOT EXECUTED 10ab07: c9 leave <== NOT EXECUTED 10ab08: c3 ret <== NOT EXECUTED 0010b51c <_ISR_Handler_initialization>: * * Output parameters: NONE */ void _ISR_Handler_initialization( void ) { 10b51c: 55 push %ebp <== NOT EXECUTED 10b51d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b51f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED _ISR_Signals_to_thread_executing = FALSE; 10b522: c6 05 68 eb 11 00 00 movb $0x0,0x11eb68 <== NOT EXECUTED _ISR_Nest_level = 0; 10b529: c7 05 98 ea 11 00 00 movl $0x0,0x11ea98 <== NOT EXECUTED 10b530: 00 00 00 <== NOT EXECUTED _CPU_Initialize_vectors(); #if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE ) if ( !_Stack_Is_enough(_Configuration_Table->interrupt_stack_size) ) 10b533: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10b538: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10b53b: 3b 05 b0 a4 11 00 cmp 0x11a4b0,%eax <== NOT EXECUTED 10b541: 72 21 jb 10b564 <_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( 10b543: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b546: 50 push %eax <== NOT EXECUTED 10b547: e8 a8 1e 00 00 call 10d3f4 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b54c: a3 08 ea 11 00 mov %eax,0x11ea08 <== NOT EXECUTED _Configuration_Table->interrupt_stack_size ); _CPU_Interrupt_stack_high = _Addresses_Add_offset( 10b551: 8b 15 94 ea 11 00 mov 0x11ea94,%edx <== NOT EXECUTED 10b557: 03 42 1c add 0x1c(%edx),%eax <== NOT EXECUTED 10b55a: a3 c8 e9 11 00 mov %eax,0x11e9c8 <== NOT EXECUTED 10b55f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE ) _CPU_Install_interrupt_stack(); #endif } 10b562: c9 leave <== NOT EXECUTED 10b563: 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( 10b564: 50 push %eax <== NOT EXECUTED 10b565: 6a 05 push $0x5 <== NOT EXECUTED 10b567: 6a 01 push $0x1 <== NOT EXECUTED 10b569: 6a 00 push $0x0 <== NOT EXECUTED 10b56b: e8 6c ff ff ff call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED 0010b4dc <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10b4dc: 55 push %ebp <== NOT EXECUTED 10b4dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b4df: 53 push %ebx <== NOT EXECUTED 10b4e0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b4e3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b4e6: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b4e9: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED _Internal_errors_What_happened.the_source = the_source; 10b4ec: 89 15 a4 ea 11 00 mov %edx,0x11eaa4 <== NOT EXECUTED _Internal_errors_What_happened.is_internal = is_internal; 10b4f2: a2 a8 ea 11 00 mov %al,0x11eaa8 <== NOT EXECUTED _Internal_errors_What_happened.the_error = the_error; 10b4f7: 89 1d ac ea 11 00 mov %ebx,0x11eaac <== NOT EXECUTED _User_extensions_Fatal( the_source, is_internal, the_error ); 10b4fd: 53 push %ebx <== NOT EXECUTED 10b4fe: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 10b501: 50 push %eax <== NOT EXECUTED 10b502: 52 push %edx <== NOT EXECUTED 10b503: e8 60 1b 00 00 call 10d068 <_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( 10b508: c7 05 c4 eb 11 00 05 movl $0x5,0x11ebc4 <== NOT EXECUTED 10b50f: 00 00 00 <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10b512: fa cli <== NOT EXECUTED 10b513: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b515: f4 hlt <== NOT EXECUTED 10b516: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b519: eb fe jmp 10b519 <_Internal_error_Occurred+0x3d> <== NOT EXECUTED 0010ec0c <_Interrupt_Manager_initialization>: * * Output parameters: NONE */ void _Interrupt_Manager_initialization( void ) { 10ec0c: 55 push %ebp <== NOT EXECUTED 10ec0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED } 10ec0f: c9 leave <== NOT EXECUTED 10ec10: c3 ret <== NOT EXECUTED 001259bc <_Message_queue_Allocate>: * Output parameters: * the_message_queue - set if successful, NULL otherwise */ Message_queue_Control *_Message_queue_Allocate(void) { 1259bc: 55 push %ebp <== NOT EXECUTED 1259bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1259bf: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED return (Message_queue_Control *) 1259c2: 68 a0 16 16 00 push $0x1616a0 <== NOT EXECUTED 1259c7: e8 20 ae fe ff call 1107ec <_Objects_Allocate> <== NOT EXECUTED _Objects_Allocate(&_Message_queue_Information); } 1259cc: c9 leave <== NOT EXECUTED 1259cd: c3 ret <== NOT EXECUTED 0010ec14 <_Message_queue_Manager_initialization>: */ void _Message_queue_Manager_initialization( uint32_t maximum_message_queues ) { 10ec14: 55 push %ebp <== NOT EXECUTED 10ec15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ec17: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ec1a: 6a 04 push $0x4 <== NOT EXECUTED 10ec1c: 6a 00 push $0x0 <== NOT EXECUTED 10ec1e: 68 88 00 00 00 push $0x88 <== NOT EXECUTED 10ec23: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ec26: 6a 04 push $0x4 <== NOT EXECUTED 10ec28: 6a 02 push $0x2 <== NOT EXECUTED 10ec2a: 68 20 ed 11 00 push $0x11ed20 <== NOT EXECUTED 10ec2f: e8 94 ce ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10ec34: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_MESSAGE_QUEUE, _Message_queue_MP_Process_packet ); #endif } 10ec37: c9 leave <== NOT EXECUTED 10ec38: 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 34 c8 11 00 mov 0x11c834(,%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 0010f454 <_Objects_API_maximum_class>: #include int _Objects_API_maximum_class( uint32_t api ) { 10f454: 55 push %ebp <== NOT EXECUTED 10f455: 89 e5 mov %esp,%ebp <== NOT EXECUTED switch (api) { 10f457: 83 7d 08 02 cmpl $0x2,0x8(%ebp) <== NOT EXECUTED 10f45b: 74 2f je 10f48c <_Objects_API_maximum_class+0x38> <== NOT EXECUTED 10f45d: 76 15 jbe 10f474 <_Objects_API_maximum_class+0x20> <== NOT EXECUTED 10f45f: 83 7d 08 03 cmpl $0x3,0x8(%ebp) <== NOT EXECUTED 10f463: 74 1f je 10f484 <_Objects_API_maximum_class+0x30> <== NOT EXECUTED 10f465: 83 7d 08 04 cmpl $0x4,0x8(%ebp) <== NOT EXECUTED 10f469: 75 0f jne 10f47a <_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; 10f46b: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10f470: c9 leave <== NOT EXECUTED 10f471: c3 ret <== NOT EXECUTED 10f472: 66 90 xchg %ax,%ax <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10f474: 83 7d 08 01 cmpl $0x1,0x8(%ebp) <== NOT EXECUTED 10f478: 74 1a je 10f494 <_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; 10f47a: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10f47f: c9 leave <== NOT EXECUTED 10f480: c3 ret <== NOT EXECUTED 10f481: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10f484: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10f489: c9 leave <== NOT EXECUTED 10f48a: c3 ret <== NOT EXECUTED 10f48b: 90 nop <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10f48c: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10f491: c9 leave <== NOT EXECUTED 10f492: c3 ret <== NOT EXECUTED 10f493: 90 nop <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10f494: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10f499: c9 leave <== NOT EXECUTED 10f49a: c3 ret <== NOT EXECUTED 0010b570 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10b570: 55 push %ebp <== NOT EXECUTED 10b571: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b573: 56 push %esi <== NOT EXECUTED 10b574: 53 push %ebx <== NOT EXECUTED 10b575: 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 ) 10b578: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10b57b: 85 c0 test %eax,%eax <== NOT EXECUTED 10b57d: 75 0d jne 10b58c <_Objects_Allocate+0x1c> <== NOT EXECUTED 10b57f: 31 c9 xor %ecx,%ecx <== NOT EXECUTED information->inactive--; } } return the_object; } 10b581: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b583: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b586: 5b pop %ebx <== NOT EXECUTED 10b587: 5e pop %esi <== NOT EXECUTED 10b588: c9 leave <== NOT EXECUTED 10b589: c3 ret <== NOT EXECUTED 10b58a: 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 ); 10b58c: 8d 73 20 lea 0x20(%ebx),%esi <== NOT EXECUTED 10b58f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b592: 56 push %esi <== NOT EXECUTED 10b593: e8 c4 f7 ff ff call 10ad5c <_Chain_Get> <== NOT EXECUTED 10b598: 89 c1 mov %eax,%ecx <== NOT EXECUTED if ( information->auto_extend ) { 10b59a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b59d: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10b5a1: 74 de je 10b581 <_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 ) { 10b5a3: 85 c0 test %eax,%eax <== NOT EXECUTED 10b5a5: 74 2d je 10b5d4 <_Objects_Allocate+0x64> <== NOT EXECUTED } if ( the_object ) { uint32_t block; block = _Objects_Get_index( the_object->id ) - 10b5a7: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10b5aa: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10b5af: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10b5b2: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10b5b8: 29 d0 sub %edx,%eax <== NOT EXECUTED _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 10b5ba: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b5bc: f7 73 14 divl 0x14(%ebx) <== NOT EXECUTED 10b5bf: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b5c2: 03 43 30 add 0x30(%ebx),%eax <== NOT EXECUTED 10b5c5: ff 08 decl (%eax) <== NOT EXECUTED information->inactive--; 10b5c7: 66 ff 4b 2c decw 0x2c(%ebx) <== NOT EXECUTED } } return the_object; } 10b5cb: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10b5cd: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b5d0: 5b pop %ebx <== NOT EXECUTED 10b5d1: 5e pop %esi <== NOT EXECUTED 10b5d2: c9 leave <== NOT EXECUTED 10b5d3: 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 ); 10b5d4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b5d7: 53 push %ebx <== NOT EXECUTED 10b5d8: e8 37 00 00 00 call 10b614 <_Objects_Extend_information> <== NOT EXECUTED the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10b5dd: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10b5e0: e8 77 f7 ff ff call 10ad5c <_Chain_Get> <== NOT EXECUTED 10b5e5: 89 c1 mov %eax,%ecx <== NOT EXECUTED } if ( the_object ) { 10b5e7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b5ea: 85 c0 test %eax,%eax <== NOT EXECUTED 10b5ec: 74 93 je 10b581 <_Objects_Allocate+0x11> <== NOT EXECUTED 10b5ee: eb b7 jmp 10b5a7 <_Objects_Allocate+0x37> <== NOT EXECUTED 0010b5f0 <_Objects_Close>: void _Objects_Close( Objects_Information *information, Objects_Control *the_object ) { 10b5f0: 55 push %ebp <== NOT EXECUTED 10b5f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b5f3: 53 push %ebx <== NOT EXECUTED 10b5f4: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b5f7: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10b5fa: 0f b7 51 08 movzwl 0x8(%ecx),%edx <== NOT EXECUTED 10b5fe: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10b601: 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 ); 10b608: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED } 10b60b: 5b pop %ebx <== NOT EXECUTED 10b60c: c9 leave <== NOT EXECUTED Objects_Control *the_object ) { _Objects_Invalidate_Id( information, the_object ); _Objects_Namespace_remove( information, the_object ); 10b60d: e9 76 05 00 00 jmp 10bb88 <_Objects_Namespace_remove> <== NOT EXECUTED 0010b614 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 10b614: 55 push %ebp <== NOT EXECUTED 10b615: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b617: 57 push %edi <== NOT EXECUTED 10b618: 56 push %esi <== NOT EXECUTED 10b619: 53 push %ebx <== NOT EXECUTED 10b61a: 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 10b61d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b620: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10b623: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10b628: 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 ) 10b62b: 0f b7 72 10 movzwl 0x10(%edx),%esi <== NOT EXECUTED 10b62f: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10b631: 0f 83 e9 01 00 00 jae 10b820 <_Objects_Extend_information+0x20c> <== NOT EXECUTED 10b637: 8b 4a 14 mov 0x14(%edx),%ecx <== NOT EXECUTED 10b63a: 89 4d a8 mov %ecx,-0x58(%ebp) <== NOT EXECUTED 10b63d: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED 10b640: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp) <== NOT EXECUTED 10b647: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b649: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) <== NOT EXECUTED 10b650: ba 03 00 00 00 mov $0x3,%edx <== NOT EXECUTED * Up the block count and maximum */ block_count++; maximum = information->maximum + information->allocation_size; 10b655: 03 75 a8 add -0x58(%ebp),%esi <== NOT EXECUTED 10b658: 89 75 d4 mov %esi,-0x2c(%ebp) <== NOT EXECUTED /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 10b65b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b65e: 80 78 12 00 cmpb $0x0,0x12(%eax) <== NOT EXECUTED 10b662: 0f 85 1c 02 00 00 jne 10b884 <_Objects_Extend_information+0x270> <== NOT EXECUTED if ( !object_blocks ) return; } else { object_blocks = (void**) 10b668: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b66b: 8b 75 c8 mov -0x38(%ebp),%esi <== NOT EXECUTED 10b66e: 8d 04 32 lea (%edx,%esi,1),%eax <== NOT EXECUTED 10b671: 03 45 d4 add -0x2c(%ebp),%eax <== NOT EXECUTED 10b674: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b677: 50 push %eax <== NOT EXECUTED 10b678: e8 77 1d 00 00 call 10d3f4 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b67d: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED 10b680: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 10b683: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED 10b686: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10b689: 8d 3c b8 lea (%eax,%edi,4),%edi <== NOT EXECUTED 10b68c: 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 10b68f: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 10b692: 8d 14 d0 lea (%eax,%edx,8),%edx <== NOT EXECUTED 10b695: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 10b698: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b69b: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 10b69f: 3b 45 c8 cmp -0x38(%ebp),%eax <== NOT EXECUTED 10b6a2: 0f 87 38 02 00 00 ja 10b8e0 <_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++ ) { 10b6a8: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 10b6ab: 85 c0 test %eax,%eax <== NOT EXECUTED 10b6ad: 74 15 je 10b6c4 <_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, 10b6af: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b6b1: 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; 10b6b4: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 10b6b7: 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++ ) { 10b6be: 40 inc %eax <== NOT EXECUTED 10b6bf: 3b 45 c8 cmp -0x38(%ebp),%eax <== NOT EXECUTED 10b6c2: 72 f0 jb 10b6b4 <_Objects_Extend_information+0xa0> <== NOT EXECUTED /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 10b6c4: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 10b6c7: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b6ca: 8b 4d cc mov -0x34(%ebp),%ecx <== NOT EXECUTED 10b6cd: c7 04 01 00 00 00 00 movl $0x0,(%ecx,%eax,1) <== NOT EXECUTED inactive_per_block[block_count] = 0; 10b6d4: 8b 75 d0 mov -0x30(%ebp),%esi <== NOT EXECUTED 10b6d7: c7 04 06 00 00 00 00 movl $0x0,(%esi,%eax,1) <== NOT EXECUTED for ( index=index_base ; index < ( information->allocation_size + index_base ); 10b6de: 8b 4d c4 mov -0x3c(%ebp),%ecx <== NOT EXECUTED 10b6e1: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b6e4: 03 4f 14 add 0x14(%edi),%ecx <== NOT EXECUTED 10b6e7: 3b 4d c4 cmp -0x3c(%ebp),%ecx <== NOT EXECUTED 10b6ea: 76 1a jbe 10b706 <_Objects_Extend_information+0xf2> <== NOT EXECUTED 10b6ec: 8b 45 c4 mov -0x3c(%ebp),%eax <== NOT EXECUTED 10b6ef: 8b 75 d8 mov -0x28(%ebp),%esi <== NOT EXECUTED 10b6f2: 8d 14 86 lea (%esi,%eax,4),%edx <== NOT EXECUTED 10b6f5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED index++ ) { local_table[ index ] = NULL; 10b6f8: 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++ ) { 10b6fe: 40 inc %eax <== NOT EXECUTED 10b6ff: 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 ); 10b702: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 10b704: 77 f2 ja 10b6f8 <_Objects_Extend_information+0xe4> <== NOT EXECUTED index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 10b706: 9c pushf <== NOT EXECUTED 10b707: fa cli <== NOT EXECUTED 10b708: 59 pop %ecx <== NOT EXECUTED old_tables = information->object_blocks; 10b709: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b70c: 8b 77 34 mov 0x34(%edi),%esi <== NOT EXECUTED information->object_blocks = object_blocks; 10b70f: 8b 45 cc mov -0x34(%ebp),%eax <== NOT EXECUTED 10b712: 89 47 34 mov %eax,0x34(%edi) <== NOT EXECUTED information->inactive_per_block = inactive_per_block; 10b715: 8b 55 d0 mov -0x30(%ebp),%edx <== NOT EXECUTED 10b718: 89 57 30 mov %edx,0x30(%edi) <== NOT EXECUTED information->local_table = local_table; 10b71b: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 10b71e: 89 47 1c mov %eax,0x1c(%edi) <== NOT EXECUTED information->maximum = maximum; 10b721: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 10b724: 66 89 57 10 mov %dx,0x10(%edi) <== NOT EXECUTED information->maximum_id = _Objects_Build_id( 10b728: 8b 17 mov (%edi),%edx <== NOT EXECUTED 10b72a: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10b72d: 81 ca 00 00 01 00 or $0x10000,%edx <== NOT EXECUTED 10b733: 0f b7 47 04 movzwl 0x4(%edi),%eax <== NOT EXECUTED 10b737: c1 e0 1b shl $0x1b,%eax <== NOT EXECUTED 10b73a: 09 c2 or %eax,%edx <== NOT EXECUTED 10b73c: 0f b7 45 d4 movzwl -0x2c(%ebp),%eax <== NOT EXECUTED 10b740: 09 c2 or %eax,%edx <== NOT EXECUTED 10b742: 89 57 0c mov %edx,0xc(%edi) <== NOT EXECUTED information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 10b745: 51 push %ecx <== NOT EXECUTED 10b746: 9d popf <== NOT EXECUTED if ( old_tables ) 10b747: 85 f6 test %esi,%esi <== NOT EXECUTED 10b749: 0f 84 c9 01 00 00 je 10b918 <_Objects_Extend_information+0x304> <== NOT EXECUTED _Workspace_Free( old_tables ); 10b74f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b752: 56 push %esi <== NOT EXECUTED 10b753: e8 6c 1c 00 00 call 10d3c4 <_Workspace_Free> <== NOT EXECUTED 10b758: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b75b: 8b 76 14 mov 0x14(%esi),%esi <== NOT EXECUTED 10b75e: 89 75 a8 mov %esi,-0x58(%ebp) <== NOT EXECUTED 10b761: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 10b764: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b767: 80 7f 12 00 cmpb $0x0,0x12(%edi) <== NOT EXECUTED 10b76b: 0f 84 3b 01 00 00 je 10b8ac <_Objects_Extend_information+0x298> <== NOT EXECUTED information->object_blocks[ block ] = 10b771: c1 e3 02 shl $0x2,%ebx <== NOT EXECUTED 10b774: 89 5d dc mov %ebx,-0x24(%ebp) <== NOT EXECUTED 10b777: 03 5f 34 add 0x34(%edi),%ebx <== NOT EXECUTED 10b77a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b77d: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 10b780: 0f af 47 18 imul 0x18(%edi),%eax <== NOT EXECUTED 10b784: 50 push %eax <== NOT EXECUTED 10b785: e8 52 1c 00 00 call 10d3dc <_Workspace_Allocate> <== NOT EXECUTED 10b78a: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Workspace_Allocate( (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 10b78c: 8b 47 34 mov 0x34(%edi),%eax <== NOT EXECUTED 10b78f: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10b792: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10b795: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b798: 85 c0 test %eax,%eax <== NOT EXECUTED 10b79a: 74 7a je 10b816 <_Objects_Extend_information+0x202> <== NOT EXECUTED /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 10b79c: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b79f: ff 71 18 pushl 0x18(%ecx) <== NOT EXECUTED 10b7a2: ff 71 14 pushl 0x14(%ecx) <== NOT EXECUTED 10b7a5: 50 push %eax <== NOT EXECUTED 10b7a6: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 10b7a9: 56 push %esi <== NOT EXECUTED 10b7aa: e8 45 38 00 00 call 10eff4 <_Chain_Initialize> <== NOT EXECUTED information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10b7af: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10b7b2: 83 c6 20 add $0x20,%esi <== NOT EXECUTED 10b7b5: 8b 5d c4 mov -0x3c(%ebp),%ebx <== NOT EXECUTED 10b7b8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b7bb: eb 2c jmp 10b7e9 <_Objects_Extend_information+0x1d5> <== NOT EXECUTED 10b7bd: 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( 10b7c0: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b7c3: 8b 07 mov (%edi),%eax <== NOT EXECUTED 10b7c5: c1 e0 18 shl $0x18,%eax <== NOT EXECUTED 10b7c8: 0d 00 00 01 00 or $0x10000,%eax <== NOT EXECUTED 10b7cd: 0f b7 57 04 movzwl 0x4(%edi),%edx <== NOT EXECUTED 10b7d1: c1 e2 1b shl $0x1b,%edx <== NOT EXECUTED 10b7d4: 09 d0 or %edx,%eax <== NOT EXECUTED 10b7d6: 09 d8 or %ebx,%eax <== NOT EXECUTED 10b7d8: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10b7db: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b7de: 51 push %ecx <== NOT EXECUTED 10b7df: 56 push %esi <== NOT EXECUTED 10b7e0: e8 53 f5 ff ff call 10ad38 <_Chain_Append> <== NOT EXECUTED index++; 10b7e5: 43 inc %ebx <== NOT EXECUTED 10b7e6: 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 ) { 10b7e9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b7ec: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10b7ef: 50 push %eax <== NOT EXECUTED 10b7f0: e8 67 f5 ff ff call 10ad5c <_Chain_Get> <== NOT EXECUTED 10b7f5: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b7f7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b7fa: 85 c0 test %eax,%eax <== NOT EXECUTED 10b7fc: 75 c2 jne 10b7c0 <_Objects_Extend_information+0x1ac> <== NOT EXECUTED _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 10b7fe: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b801: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10b804: 89 d1 mov %edx,%ecx <== NOT EXECUTED 10b806: 8b 52 14 mov 0x14(%edx),%edx <== NOT EXECUTED 10b809: 8b 75 dc mov -0x24(%ebp),%esi <== NOT EXECUTED 10b80c: 89 14 30 mov %edx,(%eax,%esi,1) <== NOT EXECUTED information->inactive += information->allocation_size; 10b80f: 8b 41 14 mov 0x14(%ecx),%eax <== NOT EXECUTED 10b812: 66 01 41 2c add %ax,0x2c(%ecx) <== NOT EXECUTED } 10b816: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b819: 5b pop %ebx <== NOT EXECUTED 10b81a: 5e pop %esi <== NOT EXECUTED 10b81b: 5f pop %edi <== NOT EXECUTED 10b81c: c9 leave <== NOT EXECUTED 10b81d: c3 ret <== NOT EXECUTED 10b81e: 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; 10b820: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b823: 8b 7f 14 mov 0x14(%edi),%edi <== NOT EXECUTED 10b826: 89 7d a8 mov %edi,-0x58(%ebp) <== NOT EXECUTED 10b829: 89 f0 mov %esi,%eax <== NOT EXECUTED 10b82b: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b82d: f7 f7 div %edi <== NOT EXECUTED 10b82f: 89 45 a4 mov %eax,-0x5c(%ebp) <== NOT EXECUTED 10b832: 89 45 c0 mov %eax,-0x40(%ebp) <== NOT EXECUTED for ( ; block < block_count; block++ ) { 10b835: 85 c0 test %eax,%eax <== NOT EXECUTED 10b837: 0f 84 e6 00 00 00 je 10b923 <_Objects_Extend_information+0x30f> <== NOT EXECUTED if ( information->object_blocks[ block ] == NULL ) 10b83d: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b840: 8b 4f 34 mov 0x34(%edi),%ecx <== NOT EXECUTED 10b843: 8b 19 mov (%ecx),%ebx <== NOT EXECUTED 10b845: 85 db test %ebx,%ebx <== NOT EXECUTED 10b847: 0f 84 d6 00 00 00 je 10b923 <_Objects_Extend_information+0x30f> <== NOT EXECUTED 10b84d: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 10b850: 89 45 c4 mov %eax,-0x3c(%ebp) <== NOT EXECUTED 10b853: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b855: eb 08 jmp 10b85f <_Objects_Extend_information+0x24b> <== NOT EXECUTED 10b857: 90 nop <== NOT EXECUTED 10b858: 8b 14 99 mov (%ecx,%ebx,4),%edx <== NOT EXECUTED 10b85b: 85 d2 test %edx,%edx <== NOT EXECUTED 10b85d: 74 0c je 10b86b <_Objects_Extend_information+0x257> <== NOT EXECUTED break; else index_base += information->allocation_size; 10b85f: 8b 55 a8 mov -0x58(%ebp),%edx <== NOT EXECUTED 10b862: 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++ ) { 10b865: 43 inc %ebx <== NOT EXECUTED 10b866: 39 5d a4 cmp %ebx,-0x5c(%ebp) <== NOT EXECUTED 10b869: 77 ed ja 10b858 <_Objects_Extend_information+0x244> <== NOT EXECUTED /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 10b86b: 39 75 c4 cmp %esi,-0x3c(%ebp) <== NOT EXECUTED 10b86e: 0f 82 f0 fe ff ff jb 10b764 <_Objects_Extend_information+0x150> <== NOT EXECUTED 10b874: 8b 7d a4 mov -0x5c(%ebp),%edi <== NOT EXECUTED 10b877: 47 inc %edi <== NOT EXECUTED 10b878: 89 7d e0 mov %edi,-0x20(%ebp) <== NOT EXECUTED 10b87b: 8d 14 7f lea (%edi,%edi,2),%edx <== NOT EXECUTED 10b87e: e9 d2 fd ff ff jmp 10b655 <_Objects_Extend_information+0x41> <== NOT EXECUTED 10b883: 90 nop <== NOT EXECUTED /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { object_blocks = (void**) 10b884: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b887: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 10b88a: 8d 04 0a lea (%edx,%ecx,1),%eax <== NOT EXECUTED 10b88d: 01 f0 add %esi,%eax <== NOT EXECUTED 10b88f: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b892: 50 push %eax <== NOT EXECUTED 10b893: e8 44 1b 00 00 call 10d3dc <_Workspace_Allocate> <== NOT EXECUTED 10b898: 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 ) 10b89b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b89e: 85 c0 test %eax,%eax <== NOT EXECUTED 10b8a0: 0f 85 dd fd ff ff jne 10b683 <_Objects_Extend_information+0x6f> <== NOT EXECUTED 10b8a6: e9 6b ff ff ff jmp 10b816 <_Objects_Extend_information+0x202> <== NOT EXECUTED 10b8ab: 90 nop <== NOT EXECUTED if ( !information->object_blocks[ block ] ) return; } else { information->object_blocks[ block ] = 10b8ac: c1 e3 02 shl $0x2,%ebx <== NOT EXECUTED 10b8af: 89 5d dc mov %ebx,-0x24(%ebp) <== NOT EXECUTED 10b8b2: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10b8b5: 03 59 34 add 0x34(%ecx),%ebx <== NOT EXECUTED 10b8b8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b8bb: 8b 75 a8 mov -0x58(%ebp),%esi <== NOT EXECUTED 10b8be: 0f af 71 18 imul 0x18(%ecx),%esi <== NOT EXECUTED 10b8c2: 56 push %esi <== NOT EXECUTED 10b8c3: e8 2c 1b 00 00 call 10d3f4 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10b8c8: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10b8ca: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b8cd: 8b 47 34 mov 0x34(%edi),%eax <== NOT EXECUTED 10b8d0: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 10b8d3: 8b 04 10 mov (%eax,%edx,1),%eax <== NOT EXECUTED 10b8d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b8d9: e9 be fe ff ff jmp 10b79c <_Objects_Extend_information+0x188> <== NOT EXECUTED 10b8de: 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, 10b8e0: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 10b8e3: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b8e6: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10b8e9: 8b 77 34 mov 0x34(%edi),%esi <== NOT EXECUTED 10b8ec: 8b 7d cc mov -0x34(%ebp),%edi <== NOT EXECUTED 10b8ef: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b8f1: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 10b8f3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b8f6: 8b 72 30 mov 0x30(%edx),%esi <== NOT EXECUTED 10b8f9: 8b 7d d0 mov -0x30(%ebp),%edi <== NOT EXECUTED 10b8fc: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b8fe: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10b900: 0f b7 4a 10 movzwl 0x10(%edx),%ecx <== NOT EXECUTED 10b904: 03 4d c8 add -0x38(%ebp),%ecx <== NOT EXECUTED 10b907: c1 e1 02 shl $0x2,%ecx <== NOT EXECUTED 10b90a: 8b 72 1c mov 0x1c(%edx),%esi <== NOT EXECUTED 10b90d: 8b 7d d8 mov -0x28(%ebp),%edi <== NOT EXECUTED 10b910: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10b912: e9 ad fd ff ff jmp 10b6c4 <_Objects_Extend_information+0xb0> <== NOT EXECUTED 10b917: 90 nop <== NOT EXECUTED information->maximum ); _ISR_Enable( level ); if ( old_tables ) 10b918: 8b 4f 14 mov 0x14(%edi),%ecx <== NOT EXECUTED 10b91b: 89 4d a8 mov %ecx,-0x58(%ebp) <== NOT EXECUTED 10b91e: e9 41 fe ff ff jmp 10b764 <_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++ ) { 10b923: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 10b926: 89 4d c4 mov %ecx,-0x3c(%ebp) <== NOT EXECUTED 10b929: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b92b: e9 3b ff ff ff jmp 10b86b <_Objects_Extend_information+0x257> <== NOT EXECUTED 0010b930 <_Objects_Free>: void _Objects_Free( Objects_Information *information, Objects_Control *the_object ) { 10b930: 55 push %ebp <== NOT EXECUTED 10b931: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b933: 57 push %edi <== NOT EXECUTED 10b934: 56 push %esi <== NOT EXECUTED 10b935: 53 push %ebx <== NOT EXECUTED 10b936: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10b939: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10b93c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED uint32_t allocation_size = information->allocation_size; 10b93f: 8b 7b 14 mov 0x14(%ebx),%edi <== NOT EXECUTED _Chain_Append( &information->Inactive, &the_object->Node ); 10b942: 56 push %esi <== NOT EXECUTED 10b943: 8d 43 20 lea 0x20(%ebx),%eax <== NOT EXECUTED 10b946: 50 push %eax <== NOT EXECUTED 10b947: e8 ec f3 ff ff call 10ad38 <_Chain_Append> <== NOT EXECUTED if ( information->auto_extend ) { 10b94c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b94f: 80 7b 12 00 cmpb $0x0,0x12(%ebx) <== NOT EXECUTED 10b953: 74 35 je 10b98a <_Objects_Free+0x5a> <== NOT EXECUTED uint32_t block; block = 10b955: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10b958: 25 ff ff 00 00 and $0xffff,%eax <== NOT EXECUTED 10b95d: 8b 53 08 mov 0x8(%ebx),%edx <== NOT EXECUTED 10b960: 81 e2 ff ff 00 00 and $0xffff,%edx <== NOT EXECUTED 10b966: 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 ]++; 10b968: 31 d2 xor %edx,%edx <== NOT EXECUTED 10b96a: f7 73 14 divl 0x14(%ebx) <== NOT EXECUTED 10b96d: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10b970: 03 43 30 add 0x30(%ebx),%eax <== NOT EXECUTED 10b973: ff 00 incl (%eax) <== NOT EXECUTED information->inactive++; 10b975: 8b 53 2c mov 0x2c(%ebx),%edx <== NOT EXECUTED 10b978: 42 inc %edx <== NOT EXECUTED 10b979: 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 ) ) ) { 10b97d: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10b980: 89 f8 mov %edi,%eax <== NOT EXECUTED 10b982: d1 e8 shr %eax <== NOT EXECUTED 10b984: 01 f8 add %edi,%eax <== NOT EXECUTED 10b986: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10b988: 77 0a ja 10b994 <_Objects_Free+0x64> <== NOT EXECUTED _Objects_Shrink_information( information ); } } } 10b98a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b98d: 5b pop %ebx <== NOT EXECUTED 10b98e: 5e pop %esi <== NOT EXECUTED 10b98f: 5f pop %edi <== NOT EXECUTED 10b990: c9 leave <== NOT EXECUTED 10b991: c3 ret <== NOT EXECUTED 10b992: 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 ); 10b994: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } } 10b997: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b99a: 5b pop %ebx <== NOT EXECUTED 10b99b: 5e pop %esi <== NOT EXECUTED 10b99c: 5f pop %edi <== NOT EXECUTED 10b99d: 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 ); 10b99e: e9 a5 02 00 00 jmp 10bc48 <_Objects_Shrink_information> <== NOT EXECUTED 0010ba64 <_Objects_Get>: Objects_Control *_Objects_Get( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 10ba64: 55 push %ebp <== NOT EXECUTED 10ba65: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ba67: 53 push %ebx <== NOT EXECUTED 10ba68: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10ba6b: 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; 10ba6e: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10ba73: 2b 51 08 sub 0x8(%ecx),%edx <== NOT EXECUTED 10ba76: 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 ) { 10ba79: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 10ba7d: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10ba7f: 77 27 ja 10baa8 <_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 10ba81: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10ba86: 40 inc %eax <== NOT EXECUTED 10ba87: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED _Thread_Disable_dispatch(); if ( (the_object = information->local_table[ index ]) != NULL ) { 10ba8c: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 10ba8f: 8b 1c 90 mov (%eax,%edx,4),%ebx <== NOT EXECUTED 10ba92: 85 db test %ebx,%ebx <== NOT EXECUTED 10ba94: 74 1f je 10bab5 <_Objects_Get+0x51> <== NOT EXECUTED *location = OBJECTS_LOCAL; 10ba96: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10ba99: 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 } 10ba9f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10baa1: 5a pop %edx <== NOT EXECUTED 10baa2: 5b pop %ebx <== NOT EXECUTED 10baa3: c9 leave <== NOT EXECUTED 10baa4: c3 ret <== NOT EXECUTED 10baa5: 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; 10baa8: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10baab: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10bab1: 31 db xor %ebx,%ebx <== NOT EXECUTED 10bab3: eb ea jmp 10ba9f <_Objects_Get+0x3b> <== NOT EXECUTED /* * Valid Id for this API, Class and Node but the object has not * been allocated yet. */ _Thread_Enable_dispatch(); 10bab5: e8 ee 07 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED *location = OBJECTS_ERROR; 10baba: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10babd: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10bac3: eb da jmp 10ba9f <_Objects_Get+0x3b> <== NOT EXECUTED 0010b9c4 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint32_t the_class ) { 10b9c4: 55 push %ebp <== NOT EXECUTED 10b9c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b9c7: 53 push %ebx <== NOT EXECUTED 10b9c8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b9cb: 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. 10b9ce: 8d 43 ff lea -0x1(%ebx),%eax <== NOT EXECUTED 10b9d1: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10b9d4: 77 07 ja 10b9dd <_Objects_Get_information+0x19> <== NOT EXECUTED int the_class_api_maximum; if ( !_Objects_Is_api_valid( the_api ) ) return NULL; if ( !the_class ) 10b9d6: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b9d9: 85 c0 test %eax,%eax <== NOT EXECUTED 10b9db: 75 07 jne 10b9e4 <_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 ) 10b9dd: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; #endif return info; } 10b9df: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b9e2: c9 leave <== NOT EXECUTED 10b9e3: c3 ret <== NOT EXECUTED return NULL; if ( !the_class ) return NULL; the_class_api_maximum = _Objects_API_maximum_class( the_api ); 10b9e4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b9e7: 53 push %ebx <== NOT EXECUTED 10b9e8: e8 67 3a 00 00 call 10f454 <_Objects_API_maximum_class> <== NOT EXECUTED if ( the_class_api_maximum < 0 || 10b9ed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b9f0: 85 c0 test %eax,%eax <== NOT EXECUTED 10b9f2: 78 e9 js 10b9dd <_Objects_Get_information+0x19> <== NOT EXECUTED 10b9f4: 39 45 0c cmp %eax,0xc(%ebp) <== NOT EXECUTED 10b9f7: 77 e4 ja 10b9dd <_Objects_Get_information+0x19> <== NOT EXECUTED the_class > (uint32_t) the_class_api_maximum ) return NULL; if ( !_Objects_Information_table[ the_api ] ) 10b9f9: 8b 04 9d cc e9 11 00 mov 0x11e9cc(,%ebx,4),%eax <== NOT EXECUTED 10ba00: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba02: 74 d9 je 10b9dd <_Objects_Get_information+0x19> <== NOT EXECUTED return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10ba04: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10ba07: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED if ( !info ) 10ba0a: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba0c: 74 d1 je 10b9df <_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 ) 10ba0e: 66 83 78 10 00 cmpw $0x0,0x10(%eax) <== NOT EXECUTED 10ba13: 75 ca jne 10b9df <_Objects_Get_information+0x1b> <== NOT EXECUTED 10ba15: eb c6 jmp 10b9dd <_Objects_Get_information+0x19> <== NOT EXECUTED 0010b9a4 <_Objects_Get_information_id>: #include Objects_Information *_Objects_Get_information_id( Objects_Id id ) { 10b9a4: 55 push %ebp <== NOT EXECUTED 10b9a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b9a7: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10b9aa: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED return _Objects_Get_information( 10b9ad: 89 c2 mov %eax,%edx <== NOT EXECUTED 10b9af: c1 ea 1b shr $0x1b,%edx <== NOT EXECUTED 10b9b2: 52 push %edx <== NOT EXECUTED 10b9b3: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10b9b6: 83 e0 07 and $0x7,%eax <== NOT EXECUTED 10b9b9: 50 push %eax <== NOT EXECUTED 10b9ba: e8 05 00 00 00 call 10b9c4 <_Objects_Get_information> <== NOT EXECUTED _Objects_Get_API( id ), _Objects_Get_class( id ) ); } 10b9bf: c9 leave <== NOT EXECUTED 10b9c0: c3 ret <== NOT EXECUTED 0010ba18 <_Objects_Get_isr_disable>: Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 10ba18: 55 push %ebp <== NOT EXECUTED 10ba19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ba1b: 56 push %esi <== NOT EXECUTED 10ba1c: 53 push %ebx <== NOT EXECUTED 10ba1d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10ba20: 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; 10ba23: 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 ); 10ba27: 9c pushf <== NOT EXECUTED 10ba28: fa cli <== NOT EXECUTED 10ba29: 59 pop %ecx <== NOT EXECUTED if ( information->maximum >= index ) { 10ba2a: 0f b7 43 10 movzwl 0x10(%ebx),%eax <== NOT EXECUTED 10ba2e: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10ba30: 77 1a ja 10ba4c <_Objects_Get_isr_disable+0x34> <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { 10ba32: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10ba35: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED 10ba38: 85 c0 test %eax,%eax <== NOT EXECUTED 10ba3a: 74 1c je 10ba58 <_Objects_Get_isr_disable+0x40> <== NOT EXECUTED *location = OBJECTS_LOCAL; 10ba3c: c7 06 00 00 00 00 movl $0x0,(%esi) <== NOT EXECUTED *level_p = level; 10ba42: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10ba45: 89 0a mov %ecx,(%edx) <== NOT EXECUTED _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10ba47: 5b pop %ebx <== NOT EXECUTED 10ba48: 5e pop %esi <== NOT EXECUTED 10ba49: c9 leave <== NOT EXECUTED 10ba4a: c3 ret <== NOT EXECUTED 10ba4b: 90 nop <== NOT EXECUTED } _ISR_Enable( level ); *location = OBJECTS_ERROR; return NULL; } _ISR_Enable( level ); 10ba4c: 51 push %ecx <== NOT EXECUTED 10ba4d: 9d popf <== NOT EXECUTED *location = OBJECTS_ERROR; 10ba4e: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10ba54: 31 c0 xor %eax,%eax <== NOT EXECUTED 10ba56: eb ef jmp 10ba47 <_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 ); 10ba58: 51 push %ecx <== NOT EXECUTED 10ba59: 9d popf <== NOT EXECUTED *location = OBJECTS_ERROR; 10ba5a: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10ba60: eb e5 jmp 10ba47 <_Objects_Get_isr_disable+0x2f> <== NOT EXECUTED 001163f8 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 1163f8: 55 push %ebp <== NOT EXECUTED 1163f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1163fb: 57 push %edi <== NOT EXECUTED 1163fc: 56 push %esi <== NOT EXECUTED 1163fd: 53 push %ebx <== NOT EXECUTED 1163fe: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 116401: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 116404: 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 ) 116407: 85 f6 test %esi,%esi <== NOT EXECUTED 116409: 75 0d jne 116418 <_Objects_Get_name_as_string+0x20> <== NOT EXECUTED } } *d = '\0'; _Thread_Enable_dispatch(); return name; 11640b: 31 db xor %ebx,%ebx <== NOT EXECUTED } return NULL; /* unreachable path */ } 11640d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11640f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116412: 5b pop %ebx <== NOT EXECUTED 116413: 5e pop %esi <== NOT EXECUTED 116414: 5f pop %edi <== NOT EXECUTED 116415: c9 leave <== NOT EXECUTED 116416: c3 ret <== NOT EXECUTED 116417: 90 nop <== NOT EXECUTED Objects_Id tmpId; if ( length == 0 ) return NULL; if ( name == NULL ) 116418: 85 db test %ebx,%ebx <== NOT EXECUTED 11641a: 74 f1 je 11640d <_Objects_Get_name_as_string+0x15> <== NOT EXECUTED return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 11641c: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 11641f: 85 ff test %edi,%edi <== NOT EXECUTED 116421: 0f 84 8d 00 00 00 je 1164b4 <_Objects_Get_name_as_string+0xbc> <== NOT EXECUTED 116427: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 11642a: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 11642d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116430: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 116433: e8 78 a3 ff ff call 1107b0 <_Objects_Get_information_id> <== NOT EXECUTED 116438: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( !information ) 11643a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11643d: 85 c0 test %eax,%eax <== NOT EXECUTED 11643f: 74 ca je 11640b <_Objects_Get_name_as_string+0x13> <== NOT EXECUTED return NULL; the_object = _Objects_Get( information, tmpId, &location ); 116441: 51 push %ecx <== NOT EXECUTED 116442: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 116445: 50 push %eax <== NOT EXECUTED 116446: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 116449: 57 push %edi <== NOT EXECUTED 11644a: e8 21 a4 ff ff call 110870 <_Objects_Get> <== NOT EXECUTED switch ( location ) { 11644f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116452: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 116455: 85 d2 test %edx,%edx <== NOT EXECUTED 116457: 75 b2 jne 11640b <_Objects_Get_name_as_string+0x13> <== NOT EXECUTED case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 116459: 80 7f 38 00 cmpb $0x0,0x38(%edi) <== NOT EXECUTED 11645d: 74 65 je 1164c4 <_Objects_Get_name_as_string+0xcc> <== NOT EXECUTED s = the_object->name.name_p; 11645f: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 116462: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED lname[ 4 ] = '\0'; s = lname; } d = name; if ( s ) { 116465: 85 c0 test %eax,%eax <== NOT EXECUTED 116467: 0f 84 84 00 00 00 je 1164f1 <_Objects_Get_name_as_string+0xf9> <== NOT EXECUTED for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 11646d: 4e dec %esi <== NOT EXECUTED 11646e: 89 75 d8 mov %esi,-0x28(%ebp) <== NOT EXECUTED 116471: 74 7e je 1164f1 <_Objects_Get_name_as_string+0xf9> <== NOT EXECUTED 116473: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 116476: 8a 08 mov (%eax),%cl <== NOT EXECUTED 116478: 84 c9 test %cl,%cl <== NOT EXECUTED 11647a: 74 75 je 1164f1 <_Objects_Get_name_as_string+0xf9> <== NOT EXECUTED 11647c: 89 df mov %ebx,%edi <== NOT EXECUTED 11647e: 31 f6 xor %esi,%esi <== NOT EXECUTED 116480: eb 0c jmp 11648e <_Objects_Get_name_as_string+0x96> <== NOT EXECUTED 116482: 66 90 xchg %ax,%ax <== NOT EXECUTED 116484: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 116487: 8a 0c 30 mov (%eax,%esi,1),%cl <== NOT EXECUTED 11648a: 84 c9 test %cl,%cl <== NOT EXECUTED 11648c: 74 19 je 1164a7 <_Objects_Get_name_as_string+0xaf> <== NOT EXECUTED *d = (isprint(*s)) ? *s : '*'; 11648e: 0f be d1 movsbl %cl,%edx <== NOT EXECUTED 116491: a1 88 a1 12 00 mov 0x12a188,%eax <== NOT EXECUTED 116496: f6 04 10 97 testb $0x97,(%eax,%edx,1) <== NOT EXECUTED 11649a: 75 02 jne 11649e <_Objects_Get_name_as_string+0xa6> <== NOT EXECUTED 11649c: b1 2a mov $0x2a,%cl <== NOT EXECUTED 11649e: 88 0f mov %cl,(%edi) <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 1164a0: 46 inc %esi <== NOT EXECUTED 1164a1: 47 inc %edi <== NOT EXECUTED 1164a2: 3b 75 d8 cmp -0x28(%ebp),%esi <== NOT EXECUTED 1164a5: 72 dd jb 116484 <_Objects_Get_name_as_string+0x8c> <== NOT EXECUTED *d = (isprint(*s)) ? *s : '*'; } } *d = '\0'; 1164a7: c6 07 00 movb $0x0,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 1164aa: e8 05 ac ff ff call 1110b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 1164af: e9 59 ff ff ff jmp 11640d <_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; 1164b4: a1 9c ca 12 00 mov 0x12ca9c,%eax <== NOT EXECUTED 1164b9: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 1164bc: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 1164bf: e9 69 ff ff ff jmp 11642d <_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; 1164c4: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED lname[ 0 ] = (u32_name >> 24) & 0xff; 1164c7: 89 d0 mov %edx,%eax <== NOT EXECUTED 1164c9: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 1164cc: 88 45 eb mov %al,-0x15(%ebp) <== NOT EXECUTED lname[ 1 ] = (u32_name >> 16) & 0xff; 1164cf: 89 d0 mov %edx,%eax <== NOT EXECUTED 1164d1: c1 e8 10 shr $0x10,%eax <== NOT EXECUTED 1164d4: 88 45 ec mov %al,-0x14(%ebp) <== NOT EXECUTED lname[ 2 ] = (u32_name >> 8) & 0xff; 1164d7: 89 d0 mov %edx,%eax <== NOT EXECUTED 1164d9: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 1164dc: 88 45 ed mov %al,-0x13(%ebp) <== NOT EXECUTED lname[ 3 ] = (u32_name >> 0) & 0xff; 1164df: 88 55 ee mov %dl,-0x12(%ebp) <== NOT EXECUTED lname[ 4 ] = '\0'; 1164e2: c6 45 ef 00 movb $0x0,-0x11(%ebp) <== NOT EXECUTED 1164e6: 8d 45 eb lea -0x15(%ebp),%eax <== NOT EXECUTED 1164e9: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED 1164ec: e9 7c ff ff ff jmp 11646d <_Objects_Get_name_as_string+0x75> <== NOT EXECUTED s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 1164f1: 89 df mov %ebx,%edi <== NOT EXECUTED 1164f3: eb b2 jmp 1164a7 <_Objects_Get_name_as_string+0xaf> <== NOT EXECUTED 001189ec <_Objects_Get_next>: Objects_Information *information, Objects_Id id, Objects_Locations *location_p, Objects_Id *next_id_p ) { 1189ec: 55 push %ebp <== NOT EXECUTED 1189ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1189ef: 57 push %edi <== NOT EXECUTED 1189f0: 56 push %esi <== NOT EXECUTED 1189f1: 53 push %ebx <== NOT EXECUTED 1189f2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1189f5: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 1189f8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1189fb: 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) 1189fe: 66 85 c0 test %ax,%ax <== NOT EXECUTED 118a01: 74 2d je 118a30 <_Objects_Get_next+0x44> <== NOT EXECUTED 118a03: 89 c3 mov %eax,%ebx <== NOT EXECUTED 118a05: 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) 118a08: 66 39 5f 10 cmp %bx,0x10(%edi) <== NOT EXECUTED 118a0c: 72 2e jb 118a3c <_Objects_Get_next+0x50> <== NOT EXECUTED *location_p = OBJECTS_ERROR; goto final; } /* try to grab one */ object = _Objects_Get(information, next_id, location_p); 118a0e: 51 push %ecx <== NOT EXECUTED 118a0f: 56 push %esi <== NOT EXECUTED 118a10: 53 push %ebx <== NOT EXECUTED 118a11: 57 push %edi <== NOT EXECUTED 118a12: e8 59 7e ff ff call 110870 <_Objects_Get> <== NOT EXECUTED next_id++; 118a17: 43 inc %ebx <== NOT EXECUTED } while (*location_p != OBJECTS_LOCAL); 118a18: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 118a1b: 8b 16 mov (%esi),%edx <== NOT EXECUTED 118a1d: 85 d2 test %edx,%edx <== NOT EXECUTED 118a1f: 75 e7 jne 118a08 <_Objects_Get_next+0x1c> <== NOT EXECUTED *next_id_p = next_id; 118a21: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 118a24: 89 1a mov %ebx,(%edx) <== NOT EXECUTED return object; final: *next_id_p = OBJECTS_ID_FINAL; return 0; } 118a26: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118a29: 5b pop %ebx <== NOT EXECUTED 118a2a: 5e pop %esi <== NOT EXECUTED 118a2b: 5f pop %edi <== NOT EXECUTED 118a2c: c9 leave <== NOT EXECUTED 118a2d: c3 ret <== NOT EXECUTED 118a2e: 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; 118a30: 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) 118a33: 66 39 5f 10 cmp %bx,0x10(%edi) <== NOT EXECUTED 118a37: 73 d5 jae 118a0e <_Objects_Get_next+0x22> <== NOT EXECUTED 118a39: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { *location_p = OBJECTS_ERROR; 118a3c: 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; 118a42: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 118a45: c7 00 ff ff ff ff movl $0xffffffff,(%eax) <== NOT EXECUTED 118a4b: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 118a4d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 118a50: 5b pop %ebx <== NOT EXECUTED 118a51: 5e pop %esi <== NOT EXECUTED 118a52: 5f pop %edi <== NOT EXECUTED 118a53: c9 leave <== NOT EXECUTED 118a54: c3 ret <== NOT EXECUTED 00116b5c <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 116b5c: 55 push %ebp <== NOT EXECUTED 116b5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116b5f: 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; 116b62: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 116b67: 2b 51 08 sub 0x8(%ecx),%edx <== NOT EXECUTED 116b6a: 03 55 0c add 0xc(%ebp),%edx <== NOT EXECUTED if ( information->maximum >= index ) { 116b6d: 0f b7 41 10 movzwl 0x10(%ecx),%eax <== NOT EXECUTED 116b71: 39 c2 cmp %eax,%edx <== NOT EXECUTED 116b73: 77 17 ja 116b8c <_Objects_Get_no_protection+0x30> <== NOT EXECUTED if ( (the_object = information->local_table[ index ]) != NULL ) { 116b75: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 116b78: 8b 04 90 mov (%eax,%edx,4),%eax <== NOT EXECUTED 116b7b: 85 c0 test %eax,%eax <== NOT EXECUTED 116b7d: 74 0d je 116b8c <_Objects_Get_no_protection+0x30> <== NOT EXECUTED *location = OBJECTS_LOCAL; 116b7f: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 116b82: 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; } 116b88: c9 leave <== NOT EXECUTED 116b89: c3 ret <== NOT EXECUTED 116b8a: 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; 116b8c: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 116b8f: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 116b95: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; } 116b97: c9 leave <== NOT EXECUTED 116b98: c3 ret <== NOT EXECUTED 0010bc40 <_Objects_Handler_initialization>: uint32_t maximum_nodes, uint32_t maximum_global_objects ) #else void _Objects_Handler_initialization(void) #endif { 10bc40: 55 push %ebp <== NOT EXECUTED 10bc41: 89 e5 mov %esp,%ebp <== NOT EXECUTED node, maximum_nodes, maximum_global_objects ); #endif } 10bc43: c9 leave <== NOT EXECUTED 10bc44: c3 ret <== NOT EXECUTED 0010caf8 <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10caf8: 55 push %ebp <== NOT EXECUTED 10caf9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cafb: 53 push %ebx <== NOT EXECUTED 10cafc: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10caff: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cb02: 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 ) 10cb05: 85 db test %ebx,%ebx <== NOT EXECUTED 10cb07: 74 7b je 10cb84 <_Objects_Id_to_name+0x8c> <== NOT EXECUTED return OBJECTS_INVALID_NAME; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10cb09: 85 c0 test %eax,%eax <== NOT EXECUTED 10cb0b: 74 53 je 10cb60 <_Objects_Id_to_name+0x68> <== NOT EXECUTED 10cb0d: 89 c1 mov %eax,%ecx <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10cb0f: 89 ca mov %ecx,%edx <== NOT EXECUTED 10cb11: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10cb14: 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. 10cb17: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10cb1a: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10cb1d: 77 59 ja 10cb78 <_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 ] ) 10cb1f: 8b 14 95 8c 16 12 00 mov 0x12168c(,%edx,4),%edx <== NOT EXECUTED 10cb26: 85 d2 test %edx,%edx <== NOT EXECUTED 10cb28: 74 4e je 10cb78 <_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 ]; 10cb2a: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10cb2c: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED 10cb2f: 8b 14 82 mov (%edx,%eax,4),%edx <== NOT EXECUTED if ( !information ) 10cb32: 85 d2 test %edx,%edx <== NOT EXECUTED 10cb34: 74 42 je 10cb78 <_Objects_Id_to_name+0x80> <== NOT EXECUTED return OBJECTS_INVALID_ID; if ( information->is_string ) 10cb36: 80 7a 38 00 cmpb $0x0,0x38(%edx) <== NOT EXECUTED 10cb3a: 75 3c jne 10cb78 <_Objects_Id_to_name+0x80> <== NOT EXECUTED return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &ignored_location ); 10cb3c: 50 push %eax <== NOT EXECUTED 10cb3d: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10cb40: 50 push %eax <== NOT EXECUTED 10cb41: 51 push %ecx <== NOT EXECUTED 10cb42: 52 push %edx <== NOT EXECUTED 10cb43: e8 4c ff ff ff call 10ca94 <_Objects_Get> <== NOT EXECUTED if ( !the_object ) 10cb48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cb4b: 85 c0 test %eax,%eax <== NOT EXECUTED 10cb4d: 74 29 je 10cb78 <_Objects_Id_to_name+0x80> <== NOT EXECUTED return OBJECTS_INVALID_ID; *name = the_object->name; 10cb4f: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10cb52: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10cb54: e8 13 08 00 00 call 10d36c <_Thread_Enable_dispatch> <== NOT EXECUTED 10cb59: 31 c0 xor %eax,%eax <== NOT EXECUTED return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 10cb5b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cb5e: c9 leave <== NOT EXECUTED 10cb5f: 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; 10cb60: a1 7c 17 12 00 mov 0x12177c,%eax <== NOT EXECUTED 10cb65: 8b 48 08 mov 0x8(%eax),%ecx <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10cb68: 89 ca mov %ecx,%edx <== NOT EXECUTED 10cb6a: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10cb6d: 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. 10cb70: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10cb73: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10cb76: 76 a7 jbe 10cb1f <_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; 10cb78: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 10cb7d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cb80: c9 leave <== NOT EXECUTED 10cb81: c3 ret <== NOT EXECUTED 10cb82: 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 ) 10cb84: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10cb89: eb f2 jmp 10cb7d <_Objects_Id_to_name+0x85> <== NOT EXECUTED 0010bac8 <_Objects_Initialize_information>: , bool supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 10bac8: 55 push %ebp <== NOT EXECUTED 10bac9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bacb: 57 push %edi <== NOT EXECUTED 10bacc: 56 push %esi <== NOT EXECUTED 10bacd: 53 push %ebx <== NOT EXECUTED 10bace: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10bad1: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10bad4: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10bad7: 8b 75 20 mov 0x20(%ebp),%esi <== NOT EXECUTED 10bada: 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; 10bade: 89 17 mov %edx,(%edi) <== NOT EXECUTED information->the_class = the_class; 10bae0: 66 89 5f 04 mov %bx,0x4(%edi) <== NOT EXECUTED information->is_string = is_string; 10bae4: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 10bae7: 88 47 38 mov %al,0x38(%edi) <== NOT EXECUTED information->local_table = 0; information->inactive_per_block = 0; 10baea: c7 47 30 00 00 00 00 movl $0x0,0x30(%edi) <== NOT EXECUTED information->object_blocks = 0; 10baf1: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) <== NOT EXECUTED information->inactive = 0; 10baf8: 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; 10bafe: 8b 04 95 cc e9 11 00 mov 0x11e9cc(,%edx,4),%eax <== NOT EXECUTED 10bb05: 89 3c 98 mov %edi,(%eax,%ebx,4) <== NOT EXECUTED /* * Set the size of the object */ information->size = size; 10bb08: 89 4f 18 mov %ecx,0x18(%edi) <== NOT EXECUTED /* * Are we operating in unlimited, or auto-extend mode */ information->auto_extend = 10bb0b: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10bb0e: c1 e8 1f shr $0x1f,%eax <== NOT EXECUTED 10bb11: 88 47 12 mov %al,0x12(%edi) <== NOT EXECUTED (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE; maximum &= ~OBJECTS_UNLIMITED_OBJECTS; 10bb14: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10bb17: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx <== NOT EXECUTED /* * The allocation unit is the maximum value */ information->allocation_size = maximum; 10bb1d: 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; 10bb20: c7 47 1c 64 e7 11 00 movl $0x11e764,0x1c(%edi) <== NOT EXECUTED */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 10bb27: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10bb2a: 81 ca 00 00 01 00 or $0x10000,%edx <== NOT EXECUTED 10bb30: c1 e3 1b shl $0x1b,%ebx <== NOT EXECUTED 10bb33: 09 da or %ebx,%edx <== NOT EXECUTED 10bb35: 31 c0 xor %eax,%eax <== NOT EXECUTED 10bb37: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bb39: 0f 95 c0 setne %al <== NOT EXECUTED 10bb3c: 09 c2 or %eax,%edx <== NOT EXECUTED 10bb3e: 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) ) 10bb41: f7 c6 03 00 00 00 test $0x3,%esi <== NOT EXECUTED 10bb47: 75 23 jne 10bb6c <_Objects_Initialize_information+0xa4> <== NOT EXECUTED 10bb49: 89 f0 mov %esi,%eax <== NOT EXECUTED name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & ~(OBJECTS_NAME_ALIGNMENT-1); information->name_length = name_length; 10bb4b: 66 89 47 3a mov %ax,0x3a(%edi) <== NOT EXECUTED 10bb4f: 8d 47 24 lea 0x24(%edi),%eax <== NOT EXECUTED 10bb52: 89 47 20 mov %eax,0x20(%edi) <== NOT EXECUTED 10bb55: c7 47 24 00 00 00 00 movl $0x0,0x24(%edi) <== NOT EXECUTED 10bb5c: 8d 47 20 lea 0x20(%edi),%eax <== NOT EXECUTED 10bb5f: 89 47 28 mov %eax,0x28(%edi) <== NOT EXECUTED /* * Initialize objects .. if there are any */ if ( maximum ) { 10bb62: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10bb64: 75 0e jne 10bb74 <_Objects_Initialize_information+0xac> <== NOT EXECUTED _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10bb66: 5b pop %ebx <== NOT EXECUTED 10bb67: 5e pop %esi <== NOT EXECUTED 10bb68: 5f pop %edi <== NOT EXECUTED 10bb69: c9 leave <== NOT EXECUTED 10bb6a: c3 ret <== NOT EXECUTED 10bb6b: 90 nop <== NOT EXECUTED */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & 10bb6c: 8d 46 04 lea 0x4(%esi),%eax <== NOT EXECUTED 10bb6f: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 10bb72: eb d7 jmp 10bb4b <_Objects_Initialize_information+0x83> <== NOT EXECUTED /* * Reset the maximum value. It will be updated when the information is * extended. */ information->maximum = 0; 10bb74: 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 ); 10bb7a: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10bb7d: 5b pop %ebx <== NOT EXECUTED 10bb7e: 5e pop %esi <== NOT EXECUTED 10bb7f: 5f pop %edi <== NOT EXECUTED 10bb80: 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 ); 10bb81: e9 8e fa ff ff jmp 10b614 <_Objects_Extend_information> <== NOT EXECUTED 0010bbbc <_Objects_Name_to_id_u32>: Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) { 10bbbc: 55 push %ebp <== NOT EXECUTED 10bbbd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bbbf: 57 push %edi <== NOT EXECUTED 10bbc0: 56 push %esi <== NOT EXECUTED 10bbc1: 53 push %ebx <== NOT EXECUTED 10bbc2: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10bbc5: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == FALSE */ if ( !id ) 10bbc8: 85 ff test %edi,%edi <== NOT EXECUTED 10bbca: 74 5c je 10bc28 <_Objects_Name_to_id_u32+0x6c> <== NOT EXECUTED return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 10bbcc: 85 f6 test %esi,%esi <== NOT EXECUTED 10bbce: 74 38 je 10bc08 <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10bbd0: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bbd3: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10bbd6: 66 85 c0 test %ax,%ax <== NOT EXECUTED 10bbd9: 74 2d je 10bc08 <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED 10bbdb: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10bbde: 85 d2 test %edx,%edx <== NOT EXECUTED 10bbe0: 75 32 jne 10bc14 <_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++ ) { 10bbe2: 0f b7 d8 movzwl %ax,%ebx <== NOT EXECUTED 10bbe5: 85 db test %ebx,%ebx <== NOT EXECUTED 10bbe7: 74 1f je 10bc08 <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10bbe9: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bbec: 8b 48 1c mov 0x1c(%eax),%ecx <== NOT EXECUTED 10bbef: 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 ]; 10bbf4: 8b 04 91 mov (%ecx,%edx,4),%eax <== NOT EXECUTED if ( !the_object ) 10bbf7: 85 c0 test %eax,%eax <== NOT EXECUTED 10bbf9: 74 05 je 10bc00 <_Objects_Name_to_id_u32+0x44> <== NOT EXECUTED continue; if ( name == the_object->name.name_u32 ) { 10bbfb: 39 70 0c cmp %esi,0xc(%eax) <== NOT EXECUTED 10bbfe: 74 34 je 10bc34 <_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++ ) { 10bc00: 42 inc %edx <== NOT EXECUTED 10bc01: 39 da cmp %ebx,%edx <== NOT EXECUTED 10bc03: 76 ef jbe 10bbf4 <_Objects_Name_to_id_u32+0x38> <== NOT EXECUTED 10bc05: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10bc08: 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 } 10bc0d: 5b pop %ebx <== NOT EXECUTED 10bc0e: 5e pop %esi <== NOT EXECUTED 10bc0f: 5f pop %edi <== NOT EXECUTED 10bc10: c9 leave <== NOT EXECUTED 10bc11: c3 ret <== NOT EXECUTED 10bc12: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10bc14: 81 7d 10 ff ff ff 7f cmpl $0x7fffffff,0x10(%ebp) <== NOT EXECUTED 10bc1b: 74 c5 je 10bbe2 <_Objects_Name_to_id_u32+0x26> <== NOT EXECUTED 10bc1d: 83 7d 10 01 cmpl $0x1,0x10(%ebp) <== NOT EXECUTED 10bc21: 75 e5 jne 10bc08 <_Objects_Name_to_id_u32+0x4c> <== NOT EXECUTED 10bc23: eb bd jmp 10bbe2 <_Objects_Name_to_id_u32+0x26> <== NOT EXECUTED 10bc25: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == FALSE */ if ( !id ) 10bc28: 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 } 10bc2d: 5b pop %ebx <== NOT EXECUTED 10bc2e: 5e pop %esi <== NOT EXECUTED 10bc2f: 5f pop %edi <== NOT EXECUTED 10bc30: c9 leave <== NOT EXECUTED 10bc31: c3 ret <== NOT EXECUTED 10bc32: 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; 10bc34: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10bc37: 89 07 mov %eax,(%edi) <== NOT EXECUTED 10bc39: 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 } 10bc3b: 5b pop %ebx <== NOT EXECUTED 10bc3c: 5e pop %esi <== NOT EXECUTED 10bc3d: 5f pop %edi <== NOT EXECUTED 10bc3e: c9 leave <== NOT EXECUTED 10bc3f: c3 ret <== NOT EXECUTED 0010bb88 <_Objects_Namespace_remove>: void _Objects_Namespace_remove( Objects_Information *information, Objects_Control *the_object ) { 10bb88: 55 push %ebp <== NOT EXECUTED 10bb89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bb8b: 53 push %ebx <== NOT EXECUTED 10bb8c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bb8f: 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 ) 10bb92: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10bb95: 80 78 38 00 cmpb $0x0,0x38(%eax) <== NOT EXECUTED 10bb99: 74 13 je 10bbae <_Objects_Namespace_remove+0x26> <== NOT EXECUTED 10bb9b: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10bb9e: 85 c0 test %eax,%eax <== NOT EXECUTED 10bba0: 74 0c je 10bbae <_Objects_Namespace_remove+0x26> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10bba2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bba5: 50 push %eax <== NOT EXECUTED 10bba6: e8 19 18 00 00 call 10d3c4 <_Workspace_Free> <== NOT EXECUTED 10bbab: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Clear out either format. */ the_object->name.name_p = NULL; the_object->name.name_u32 = 0; 10bbae: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED } 10bbb5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bbb8: c9 leave <== NOT EXECUTED 10bbb9: c3 ret <== NOT EXECUTED 0010d5e0 <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 10d5e0: 55 push %ebp <== NOT EXECUTED 10d5e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d5e3: 57 push %edi <== NOT EXECUTED 10d5e4: 56 push %esi <== NOT EXECUTED 10d5e5: 53 push %ebx <== NOT EXECUTED 10d5e6: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10d5e9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10d5ec: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED size_t length; const char *s; s = name; length = strnlen( name, information->name_length ) + 1; 10d5ef: 0f b7 43 3a movzwl 0x3a(%ebx),%eax <== NOT EXECUTED 10d5f3: 50 push %eax <== NOT EXECUTED 10d5f4: 57 push %edi <== NOT EXECUTED 10d5f5: e8 5a 5c 00 00 call 113254 <== NOT EXECUTED 10d5fa: 8d 70 01 lea 0x1(%eax),%esi <== NOT EXECUTED if ( information->is_string ) { 10d5fd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d600: 80 7b 38 00 cmpb $0x0,0x38(%ebx) <== NOT EXECUTED 10d604: 75 5a jne 10d660 <_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( 10d606: 85 f6 test %esi,%esi <== NOT EXECUTED 10d608: 74 3e je 10d648 <_Objects_Set_name+0x68> <== NOT EXECUTED 10d60a: 0f be 17 movsbl (%edi),%edx <== NOT EXECUTED 10d60d: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10d610: 83 fe 01 cmp $0x1,%esi <== NOT EXECUTED 10d613: 0f 84 ae 00 00 00 je 10d6c7 <_Objects_Set_name+0xe7> <== NOT EXECUTED 10d619: 0f be 47 01 movsbl 0x1(%edi),%eax <== NOT EXECUTED 10d61d: c1 e0 10 shl $0x10,%eax <== NOT EXECUTED 10d620: 09 d0 or %edx,%eax <== NOT EXECUTED 10d622: 83 fe 02 cmp $0x2,%esi <== NOT EXECUTED 10d625: 0f 84 89 00 00 00 je 10d6b4 <_Objects_Set_name+0xd4> <== NOT EXECUTED 10d62b: 0f be 57 02 movsbl 0x2(%edi),%edx <== NOT EXECUTED 10d62f: c1 e2 08 shl $0x8,%edx <== NOT EXECUTED 10d632: 09 c2 or %eax,%edx <== NOT EXECUTED 10d634: 83 fe 03 cmp $0x3,%esi <== NOT EXECUTED 10d637: 0f 84 83 00 00 00 je 10d6c0 <_Objects_Set_name+0xe0> <== NOT EXECUTED 10d63d: 0f be 47 03 movsbl 0x3(%edi),%eax <== NOT EXECUTED 10d641: 09 d0 or %edx,%eax <== NOT EXECUTED 10d643: eb 08 jmp 10d64d <_Objects_Set_name+0x6d> <== NOT EXECUTED 10d645: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10d648: b8 20 20 20 20 mov $0x20202020,%eax <== NOT EXECUTED 10d64d: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10d650: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED 10d653: b0 01 mov $0x1,%al <== NOT EXECUTED ); } return TRUE; } 10d655: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d658: 5b pop %ebx <== NOT EXECUTED 10d659: 5e pop %esi <== NOT EXECUTED 10d65a: 5f pop %edi <== NOT EXECUTED 10d65b: c9 leave <== NOT EXECUTED 10d65c: c3 ret <== NOT EXECUTED 10d65d: 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 ); 10d660: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d663: 56 push %esi <== NOT EXECUTED 10d664: e8 ff 17 00 00 call 10ee68 <_Workspace_Allocate> <== NOT EXECUTED 10d669: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !d ) 10d66b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d66e: 85 c0 test %eax,%eax <== NOT EXECUTED 10d670: 74 4a je 10d6bc <_Objects_Set_name+0xdc> <== NOT EXECUTED return FALSE; if ( the_object->name.name_p ) { 10d672: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10d675: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10d678: 85 c0 test %eax,%eax <== NOT EXECUTED 10d67a: 74 16 je 10d692 <_Objects_Set_name+0xb2> <== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10d67c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d67f: 50 push %eax <== NOT EXECUTED 10d680: e8 cb 17 00 00 call 10ee50 <_Workspace_Free> <== NOT EXECUTED the_object->name.name_p = NULL; 10d685: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10d688: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED 10d68f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } strncpy( d, name, length ); 10d692: 50 push %eax <== NOT EXECUTED 10d693: 56 push %esi <== NOT EXECUTED 10d694: 57 push %edi <== NOT EXECUTED 10d695: 53 push %ebx <== NOT EXECUTED 10d696: e8 31 5b 00 00 call 1131cc <== NOT EXECUTED d[ length ] = '\0'; 10d69b: c6 04 33 00 movb $0x0,(%ebx,%esi,1) <== NOT EXECUTED the_object->name.name_p = d; 10d69f: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10d6a2: 89 5a 0c mov %ebx,0xc(%edx) <== NOT EXECUTED 10d6a5: b0 01 mov $0x1,%al <== NOT EXECUTED 10d6a7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ); } return TRUE; } 10d6aa: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d6ad: 5b pop %ebx <== NOT EXECUTED 10d6ae: 5e pop %esi <== NOT EXECUTED 10d6af: 5f pop %edi <== NOT EXECUTED 10d6b0: c9 leave <== NOT EXECUTED 10d6b1: c3 ret <== NOT EXECUTED 10d6b2: 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( 10d6b4: 0d 20 20 00 00 or $0x2020,%eax <== NOT EXECUTED 10d6b9: eb 92 jmp 10d64d <_Objects_Set_name+0x6d> <== NOT EXECUTED 10d6bb: 90 nop <== NOT EXECUTED if ( information->is_string ) { char *d; d = _Workspace_Allocate( length ); if ( !d ) 10d6bc: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d6be: eb 95 jmp 10d655 <_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( 10d6c0: 89 d0 mov %edx,%eax <== NOT EXECUTED 10d6c2: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 10d6c5: eb 86 jmp 10d64d <_Objects_Set_name+0x6d> <== NOT EXECUTED 10d6c7: 89 d0 mov %edx,%eax <== NOT EXECUTED 10d6c9: 0d 20 20 20 00 or $0x202020,%eax <== NOT EXECUTED 10d6ce: e9 7a ff ff ff jmp 10d64d <_Objects_Set_name+0x6d> <== NOT EXECUTED 0010bc48 <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 10bc48: 55 push %ebp <== NOT EXECUTED 10bc49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bc4b: 57 push %edi <== NOT EXECUTED 10bc4c: 56 push %esi <== NOT EXECUTED 10bc4d: 53 push %ebx <== NOT EXECUTED 10bc4e: 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 10bc51: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bc54: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10bc57: 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; 10bc5a: 8b 4a 14 mov 0x14(%edx),%ecx <== NOT EXECUTED 10bc5d: 0f b7 42 10 movzwl 0x10(%edx),%eax <== NOT EXECUTED 10bc61: 29 f0 sub %esi,%eax <== NOT EXECUTED 10bc63: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bc65: f7 f1 div %ecx <== NOT EXECUTED for ( block = 0; block < block_count; block++ ) { 10bc67: 85 c0 test %eax,%eax <== NOT EXECUTED 10bc69: 74 24 je 10bc8f <_Objects_Shrink_information+0x47> <== NOT EXECUTED if ( information->inactive_per_block[ block ] == information->allocation_size ) { 10bc6b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bc6e: 8b 5a 30 mov 0x30(%edx),%ebx <== NOT EXECUTED 10bc71: 3b 0b cmp (%ebx),%ecx <== NOT EXECUTED 10bc73: 74 22 je 10bc97 <_Objects_Shrink_information+0x4f> <== NOT EXECUTED information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; return; 10bc75: 31 d2 xor %edx,%edx <== NOT EXECUTED 10bc77: eb 11 jmp 10bc8a <_Objects_Shrink_information+0x42> <== NOT EXECUTED 10bc79: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } index_base += information->allocation_size; 10bc7c: 01 ce add %ecx,%esi <== NOT EXECUTED 10bc7e: 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 ) { 10bc85: 3b 0c 93 cmp (%ebx,%edx,4),%ecx <== NOT EXECUTED 10bc88: 74 12 je 10bc9c <_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++ ) { 10bc8a: 42 inc %edx <== NOT EXECUTED 10bc8b: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10bc8d: 77 ed ja 10bc7c <_Objects_Shrink_information+0x34> <== NOT EXECUTED return; } index_base += information->allocation_size; } } 10bc8f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bc92: 5b pop %ebx <== NOT EXECUTED 10bc93: 5e pop %esi <== NOT EXECUTED 10bc94: 5f pop %edi <== NOT EXECUTED 10bc95: c9 leave <== NOT EXECUTED 10bc96: 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 ) { 10bc97: 31 ff xor %edi,%edi <== NOT EXECUTED 10bc99: 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; 10bc9c: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bc9f: 8b 4b 20 mov 0x20(%ebx),%ecx <== NOT EXECUTED 10bca2: eb 26 jmp 10bcca <_Objects_Shrink_information+0x82> <== NOT EXECUTED */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 10bca4: 89 f0 mov %esi,%eax <== NOT EXECUTED 10bca6: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bca9: 03 43 14 add 0x14(%ebx),%eax <== NOT EXECUTED 10bcac: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10bcae: 76 24 jbe 10bcd4 <_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, 10bcb0: 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 ); 10bcb2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bcb5: 51 push %ecx <== NOT EXECUTED 10bcb6: e8 21 33 00 00 call 10efdc <_Chain_Extract> <== NOT EXECUTED 10bcbb: 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 ) ); 10bcbe: 85 db test %ebx,%ebx <== NOT EXECUTED 10bcc0: 74 1a je 10bcdc <_Objects_Shrink_information+0x94> <== NOT EXECUTED 10bcc2: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10bcc4: 85 c0 test %eax,%eax <== NOT EXECUTED 10bcc6: 74 14 je 10bcdc <_Objects_Shrink_information+0x94> <== NOT EXECUTED 10bcc8: 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 10bcca: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 10bccd: 0f b7 d0 movzwl %ax,%edx <== NOT EXECUTED */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 10bcd0: 39 f2 cmp %esi,%edx <== NOT EXECUTED 10bcd2: 73 d0 jae 10bca4 <_Objects_Shrink_information+0x5c> <== NOT EXECUTED the_object = NULL; _Chain_Extract( &extract_me->Node ); } else { the_object = (Objects_Control *) the_object->Node.next; 10bcd4: 8b 19 mov (%ecx),%ebx <== NOT EXECUTED } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 10bcd6: 85 db test %ebx,%ebx <== NOT EXECUTED 10bcd8: 75 e8 jne 10bcc2 <_Objects_Shrink_information+0x7a> <== NOT EXECUTED 10bcda: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 10bcdc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bcdf: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10bce2: 8b 42 34 mov 0x34(%edx),%eax <== NOT EXECUTED 10bce5: ff 34 38 pushl (%eax,%edi,1) <== NOT EXECUTED 10bce8: e8 d7 16 00 00 call 10d3c4 <_Workspace_Free> <== NOT EXECUTED information->object_blocks[ block ] = NULL; 10bced: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bcf0: 8b 43 34 mov 0x34(%ebx),%eax <== NOT EXECUTED 10bcf3: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1) <== NOT EXECUTED information->inactive_per_block[ block ] = 0; 10bcfa: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10bcfd: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1) <== NOT EXECUTED information->inactive -= information->allocation_size; 10bd04: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10bd07: 66 29 43 2c sub %ax,0x2c(%ebx) <== NOT EXECUTED 10bd0b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return; } index_base += information->allocation_size; } } 10bd0e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bd11: 5b pop %ebx <== NOT EXECUTED 10bd12: 5e pop %esi <== NOT EXECUTED 10bd13: 5f pop %edi <== NOT EXECUTED 10bd14: c9 leave <== NOT EXECUTED 10bd15: c3 ret <== NOT EXECUTED 0010ec3c <_Partition_Manager_initialization>: */ void _Partition_Manager_initialization( uint32_t maximum_partitions ) { 10ec3c: 55 push %ebp <== NOT EXECUTED 10ec3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ec3f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ec42: 6a 04 push $0x4 <== NOT EXECUTED 10ec44: 6a 00 push $0x0 <== NOT EXECUTED 10ec46: 6a 30 push $0x30 <== NOT EXECUTED 10ec48: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ec4b: 6a 05 push $0x5 <== NOT EXECUTED 10ec4d: 6a 02 push $0x2 <== NOT EXECUTED 10ec4f: 68 40 ee 11 00 push $0x11ee40 <== NOT EXECUTED 10ec54: e8 6f ce ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10ec59: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_PARTITION, _Partition_MP_Process_packet ); #endif } 10ec5c: c9 leave <== NOT EXECUTED 10ec5d: c3 ret <== NOT EXECUTED 0010bd18 <_Protected_heap_Allocate>: void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ) { 10bd18: 55 push %ebp <== NOT EXECUTED 10bd19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd1b: 53 push %ebx <== NOT EXECUTED 10bd1c: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *p; _RTEMS_Lock_allocator(); 10bd1f: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10bd25: e8 9a ef ff ff call 10acc4 <_API_Mutex_Lock> <== NOT EXECUTED p = _Heap_Allocate( the_heap, size ); 10bd2a: 5a pop %edx <== NOT EXECUTED 10bd2b: 59 pop %ecx <== NOT EXECUTED 10bd2c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10bd2f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bd32: e8 29 35 00 00 call 10f260 <_Heap_Allocate> <== NOT EXECUTED 10bd37: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10bd39: 58 pop %eax <== NOT EXECUTED 10bd3a: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10bd40: e8 c7 ef ff ff call 10ad0c <_API_Mutex_Unlock> <== NOT EXECUTED return p; } 10bd45: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10bd47: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bd4a: c9 leave <== NOT EXECUTED 10bd4b: c3 ret <== NOT EXECUTED 0010dbb0 <_Protected_heap_Allocate_aligned>: void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 10dbb0: 55 push %ebp <== NOT EXECUTED 10dbb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dbb3: 53 push %ebx <== NOT EXECUTED 10dbb4: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *p; _RTEMS_Lock_allocator(); 10dbb7: ff 35 b4 3c 12 00 pushl 0x123cb4 <== NOT EXECUTED 10dbbd: e8 be e9 ff ff call 10c580 <_API_Mutex_Lock> <== NOT EXECUTED p = _Heap_Allocate_aligned( the_heap, size, alignment ); 10dbc2: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10dbc5: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dbc8: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dbcb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10dbce: e8 49 f0 ff ff call 10cc1c <_Heap_Allocate_aligned> <== NOT EXECUTED 10dbd3: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10dbd5: 58 pop %eax <== NOT EXECUTED 10dbd6: ff 35 b4 3c 12 00 pushl 0x123cb4 <== NOT EXECUTED 10dbdc: e8 e7 e9 ff ff call 10c5c8 <_API_Mutex_Unlock> <== NOT EXECUTED return p; } 10dbe1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10dbe3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10dbe6: c9 leave <== NOT EXECUTED 10dbe7: c3 ret <== NOT EXECUTED 0010dc1c <_Protected_heap_Extend>: bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ) { 10dc1c: 55 push %ebp <== NOT EXECUTED 10dc1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc1f: 53 push %ebx <== NOT EXECUTED 10dc20: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Heap_Extend_status status; uint32_t amount_extended; _RTEMS_Lock_allocator(); 10dc23: ff 35 b4 3c 12 00 pushl 0x123cb4 <== NOT EXECUTED 10dc29: e8 52 e9 ff ff call 10c580 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Extend(the_heap, starting_address, size, &amount_extended); 10dc2e: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10dc31: 50 push %eax <== NOT EXECUTED 10dc32: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dc35: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10dc38: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10dc3b: e8 b8 37 00 00 call 1113f8 <_Heap_Extend> <== NOT EXECUTED 10dc40: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10dc42: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10dc45: ff 35 b4 3c 12 00 pushl 0x123cb4 <== NOT EXECUTED 10dc4b: e8 78 e9 ff ff call 10c5c8 <_API_Mutex_Unlock> <== NOT EXECUTED 10dc50: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dc53: 85 db test %ebx,%ebx <== NOT EXECUTED 10dc55: 0f 94 c0 sete %al <== NOT EXECUTED return (status == HEAP_EXTEND_SUCCESSFUL); } 10dc58: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10dc5b: c9 leave <== NOT EXECUTED 10dc5c: c3 ret <== NOT EXECUTED 0010bd4c <_Protected_heap_Free>: bool _Protected_heap_Free( Heap_Control *the_heap, void *start_address ) { 10bd4c: 55 push %ebp <== NOT EXECUTED 10bd4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd4f: 53 push %ebx <== NOT EXECUTED 10bd50: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED bool status; _RTEMS_Lock_allocator(); 10bd53: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10bd59: e8 66 ef ff ff call 10acc4 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Free( the_heap, start_address ); 10bd5e: 5a pop %edx <== NOT EXECUTED 10bd5f: 59 pop %ecx <== NOT EXECUTED 10bd60: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10bd63: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10bd66: e8 89 35 00 00 call 10f2f4 <_Heap_Free> <== NOT EXECUTED 10bd6b: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10bd6d: 58 pop %eax <== NOT EXECUTED 10bd6e: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10bd74: e8 93 ef ff ff call 10ad0c <_API_Mutex_Unlock> <== NOT EXECUTED return status; } 10bd79: 88 d8 mov %bl,%al <== NOT EXECUTED 10bd7b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bd7e: c9 leave <== NOT EXECUTED 10bd7f: c3 ret <== NOT EXECUTED 001169d8 <_Protected_heap_Get_block_size>: bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ) { 1169d8: 55 push %ebp <== NOT EXECUTED 1169d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1169db: 53 push %ebx <== NOT EXECUTED 1169dc: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED bool status; _RTEMS_Lock_allocator(); 1169df: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 1169e5: e8 da 42 ff ff call 10acc4 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Size_of_user_area( the_heap, starting_address, size ); 1169ea: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1169ed: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1169f0: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1169f3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1169f6: e8 49 02 00 00 call 116c44 <_Heap_Size_of_user_area> <== NOT EXECUTED 1169fb: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 1169fd: 58 pop %eax <== NOT EXECUTED 1169fe: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 116a04: e8 03 43 ff ff call 10ad0c <_API_Mutex_Unlock> <== NOT EXECUTED return status; } 116a09: 88 d8 mov %bl,%al <== NOT EXECUTED 116a0b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 116a0e: c9 leave <== NOT EXECUTED 116a0f: c3 ret <== NOT EXECUTED 00111134 <_Protected_heap_Get_free_information>: bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 111134: 55 push %ebp <== NOT EXECUTED 111135: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111137: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED /* * TBD: _Heap_Get_free_information does not error check or return status. */ _RTEMS_Lock_allocator(); 11113a: ff 35 d4 12 16 00 pushl 0x1612d4 <== NOT EXECUTED 111140: e8 1f eb ff ff call 10fc64 <_API_Mutex_Lock> <== NOT EXECUTED _Heap_Get_free_information( the_heap, info ); 111145: 5a pop %edx <== NOT EXECUTED 111146: 59 pop %ecx <== NOT EXECUTED 111147: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11114a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11114d: e8 ee 57 01 00 call 126940 <_Heap_Get_free_information> <== NOT EXECUTED _RTEMS_Unlock_allocator(); 111152: 58 pop %eax <== NOT EXECUTED 111153: ff 35 d4 12 16 00 pushl 0x1612d4 <== NOT EXECUTED 111159: e8 4e eb ff ff call 10fcac <_API_Mutex_Unlock> <== NOT EXECUTED return true; } 11115e: b0 01 mov $0x1,%al <== NOT EXECUTED 111160: c9 leave <== NOT EXECUTED 111161: c3 ret <== NOT EXECUTED 00126c28 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 126c28: 55 push %ebp <== NOT EXECUTED 126c29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126c2b: 56 push %esi <== NOT EXECUTED 126c2c: 53 push %ebx <== NOT EXECUTED 126c2d: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 126c30: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Heap_Get_information_status status; if ( !the_heap ) 126c33: 85 f6 test %esi,%esi <== NOT EXECUTED 126c35: 74 39 je 126c70 <_Protected_heap_Get_information+0x48> <== NOT EXECUTED return false; if ( !the_info ) 126c37: 85 db test %ebx,%ebx <== NOT EXECUTED 126c39: 74 35 je 126c70 <_Protected_heap_Get_information+0x48> <== NOT EXECUTED return false; _RTEMS_Lock_allocator(); 126c3b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 126c3e: ff 35 d4 12 16 00 pushl 0x1612d4 <== NOT EXECUTED 126c44: e8 1b 90 fe ff call 10fc64 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Get_information( the_heap, the_info ); 126c49: 5a pop %edx <== NOT EXECUTED 126c4a: 59 pop %ecx <== NOT EXECUTED 126c4b: 53 push %ebx <== NOT EXECUTED 126c4c: 56 push %esi <== NOT EXECUTED 126c4d: e8 e2 8a 00 00 call 12f734 <_Heap_Get_information> <== NOT EXECUTED 126c52: 89 c3 mov %eax,%ebx <== NOT EXECUTED _RTEMS_Unlock_allocator(); 126c54: 58 pop %eax <== NOT EXECUTED 126c55: ff 35 d4 12 16 00 pushl 0x1612d4 <== NOT EXECUTED 126c5b: e8 4c 90 fe ff call 10fcac <_API_Mutex_Unlock> <== NOT EXECUTED if ( status == HEAP_GET_INFORMATION_SUCCESSFUL ) 126c60: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126c63: 85 db test %ebx,%ebx <== NOT EXECUTED 126c65: 0f 94 c0 sete %al <== NOT EXECUTED return true; return false; } 126c68: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126c6b: 5b pop %ebx <== NOT EXECUTED 126c6c: 5e pop %esi <== NOT EXECUTED 126c6d: c9 leave <== NOT EXECUTED 126c6e: c3 ret <== NOT EXECUTED 126c6f: 90 nop <== NOT EXECUTED _RTEMS_Lock_allocator(); status = _Heap_Get_information( the_heap, the_info ); _RTEMS_Unlock_allocator(); if ( status == HEAP_GET_INFORMATION_SUCCESSFUL ) 126c70: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; return false; } 126c72: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126c75: 5b pop %ebx <== NOT EXECUTED 126c76: 5e pop %esi <== NOT EXECUTED 126c77: c9 leave <== NOT EXECUTED 126c78: c3 ret <== NOT EXECUTED 00116a10 <_Protected_heap_Resize_block>: bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ) { 116a10: 55 push %ebp <== NOT EXECUTED 116a11: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116a13: 53 push %ebx <== NOT EXECUTED 116a14: 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(); 116a17: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 116a1d: e8 a2 42 ff ff call 10acc4 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Resize_block( 116a22: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 116a25: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 116a28: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 116a2b: 50 push %eax <== NOT EXECUTED 116a2c: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 116a2f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 116a32: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 116a35: e8 1e 00 00 00 call 116a58 <_Heap_Resize_block> <== NOT EXECUTED 116a3a: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_heap, starting_address, size, &old_mem_size, &avail_mem_size ); _RTEMS_Unlock_allocator(); 116a3c: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 116a3f: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 116a45: e8 c2 42 ff ff call 10ad0c <_API_Mutex_Unlock> <== NOT EXECUTED 116a4a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116a4d: 85 db test %ebx,%ebx <== NOT EXECUTED 116a4f: 0f 94 c0 sete %al <== NOT EXECUTED return (status == HEAP_RESIZE_SUCCESSFUL); } 116a52: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 116a55: c9 leave <== NOT EXECUTED 116a56: c3 ret <== NOT EXECUTED 0010dd98 <_Protected_heap_Walk>: bool _Protected_heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 10dd98: 55 push %ebp <== NOT EXECUTED 10dd99: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dd9b: 57 push %edi <== NOT EXECUTED 10dd9c: 56 push %esi <== NOT EXECUTED 10dd9d: 53 push %ebx <== NOT EXECUTED 10dd9e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10dda1: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10dda4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10dda7: 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 ) { 10ddaa: a1 f8 3b 12 00 mov 0x123bf8,%eax <== NOT EXECUTED 10ddaf: 85 c0 test %eax,%eax <== NOT EXECUTED 10ddb1: 74 19 je 10ddcc <_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 ); 10ddb3: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10ddb6: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 10ddb9: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10ddbc: 89 7d 08 mov %edi,0x8(%ebp) <== NOT EXECUTED } return status; } 10ddbf: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ddc2: 5b pop %ebx <== NOT EXECUTED 10ddc3: 5e pop %esi <== NOT EXECUTED 10ddc4: 5f pop %edi <== NOT EXECUTED 10ddc5: 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 ); 10ddc6: e9 11 38 00 00 jmp 1115dc <_Heap_Walk> <== NOT EXECUTED 10ddcb: 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(); 10ddcc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ddcf: ff 35 b4 3c 12 00 pushl 0x123cb4 <== NOT EXECUTED 10ddd5: e8 a6 e7 ff ff call 10c580 <_API_Mutex_Lock> <== NOT EXECUTED status = _Heap_Walk( the_heap, source, do_dump ); 10ddda: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10dddd: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 10dde0: 50 push %eax <== NOT EXECUTED 10dde1: 56 push %esi <== NOT EXECUTED 10dde2: 57 push %edi <== NOT EXECUTED 10dde3: e8 f4 37 00 00 call 1115dc <_Heap_Walk> <== NOT EXECUTED 10dde8: 88 c3 mov %al,%bl <== NOT EXECUTED _RTEMS_Unlock_allocator(); 10ddea: 58 pop %eax <== NOT EXECUTED 10ddeb: ff 35 b4 3c 12 00 pushl 0x123cb4 <== NOT EXECUTED 10ddf1: e8 d2 e7 ff ff call 10c5c8 <_API_Mutex_Unlock> <== NOT EXECUTED 10ddf6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { status = _Heap_Walk( the_heap, source, do_dump ); } return status; } 10ddf9: 88 d8 mov %bl,%al <== NOT EXECUTED 10ddfb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ddfe: 5b pop %ebx <== NOT EXECUTED 10ddff: 5e pop %esi <== NOT EXECUTED 10de00: 5f pop %edi <== NOT EXECUTED 10de01: c9 leave <== NOT EXECUTED 10de02: c3 ret <== NOT EXECUTED 0010ab0c <_RTEMS_API_Initialize>: */ void _RTEMS_API_Initialize( rtems_configuration_table *configuration_table ) { 10ab0c: 55 push %ebp <== NOT EXECUTED 10ab0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ab0f: 53 push %ebx <== NOT EXECUTED 10ab10: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED rtems_api_configuration_table *api_configuration; api_configuration = configuration_table->RTEMS_api_configuration; 10ab13: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ab16: 8b 58 40 mov 0x40(%eax),%ebx <== NOT EXECUTED _Objects_Information_table[OBJECTS_CLASSIC_API] = _RTEMS_Objects; 10ab19: c7 05 d4 e9 11 00 80 movl $0x11ec80,0x11e9d4 <== NOT EXECUTED 10ab20: ec 11 00 <== NOT EXECUTED _Attributes_Handler_initialization(); _Interrupt_Manager_initialization(); 10ab23: e8 e4 40 00 00 call 10ec0c <_Interrupt_Manager_initialization> <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) _Multiprocessing_Manager_initialization(); #endif _RTEMS_tasks_Manager_initialization( api_configuration->maximum_tasks ); 10ab28: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ab2b: ff 33 pushl (%ebx) <== NOT EXECUTED 10ab2d: e8 52 42 00 00 call 10ed84 <_RTEMS_tasks_Manager_initialization> <== NOT EXECUTED _Timer_Manager_initialization( api_configuration->maximum_timers ); 10ab32: 58 pop %eax <== NOT EXECUTED 10ab33: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10ab36: e8 75 41 00 00 call 10ecb0 <_Timer_Manager_initialization> <== NOT EXECUTED _Signal_Manager_initialization(); 10ab3b: e8 cc 41 00 00 call 10ed0c <_Signal_Manager_initialization> <== NOT EXECUTED _Event_Manager_initialization(); 10ab40: e8 b7 40 00 00 call 10ebfc <_Event_Manager_initialization> <== NOT EXECUTED _Message_queue_Manager_initialization( 10ab45: 58 pop %eax <== NOT EXECUTED 10ab46: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10ab49: e8 c6 40 00 00 call 10ec14 <_Message_queue_Manager_initialization> <== NOT EXECUTED api_configuration->maximum_message_queues ); _Semaphore_Manager_initialization( api_configuration->maximum_semaphores ); 10ab4e: 58 pop %eax <== NOT EXECUTED 10ab4f: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 10ab52: e8 91 41 00 00 call 10ece8 <_Semaphore_Manager_initialization> <== NOT EXECUTED _Partition_Manager_initialization( api_configuration->maximum_partitions ); 10ab57: 58 pop %eax <== NOT EXECUTED 10ab58: ff 73 14 pushl 0x14(%ebx) <== NOT EXECUTED 10ab5b: e8 dc 40 00 00 call 10ec3c <_Partition_Manager_initialization> <== NOT EXECUTED _Region_Manager_initialization( api_configuration->maximum_regions ); 10ab60: 59 pop %ecx <== NOT EXECUTED 10ab61: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10ab64: e8 1f 41 00 00 call 10ec88 <_Region_Manager_initialization> <== NOT EXECUTED _Dual_ported_memory_Manager_initialization( api_configuration->maximum_ports); 10ab69: 5a pop %edx <== NOT EXECUTED 10ab6a: ff 73 1c pushl 0x1c(%ebx) <== NOT EXECUTED 10ab6d: e8 66 40 00 00 call 10ebd8 <_Dual_ported_memory_Manager_initialization> <== NOT EXECUTED _Rate_monotonic_Manager_initialization( api_configuration->maximum_periods ); 10ab72: 58 pop %eax <== NOT EXECUTED 10ab73: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10ab76: e8 e5 40 00 00 call 10ec60 <_Rate_monotonic_Manager_initialization> <== NOT EXECUTED _Barrier_Manager_initialization( api_configuration->maximum_barriers ); 10ab7b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ab7e: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 10ab81: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10ab84: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ab87: 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 ); 10ab88: e9 27 40 00 00 jmp 10ebb4 <_Barrier_Manager_initialization> <== NOT EXECUTED 0010ef18 <_RTEMS_Tasks_Invoke_task_variable_dtor>: void _RTEMS_Tasks_Invoke_task_variable_dtor( Thread_Control *the_thread, rtems_task_variable_t *tvp ) { 10ef18: 55 push %ebp <== NOT EXECUTED 10ef19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ef1b: 56 push %esi <== NOT EXECUTED 10ef1c: 53 push %ebx <== NOT EXECUTED 10ef1d: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED void (*dtor)(void *); void *value; dtor = tvp->dtor; 10ef20: 8b 4b 10 mov 0x10(%ebx),%ecx <== NOT EXECUTED if (_Thread_Is_executing(the_thread)) { 10ef23: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ef26: 3b 05 bc ea 11 00 cmp 0x11eabc,%eax <== NOT EXECUTED 10ef2c: 74 1e je 10ef4c <_RTEMS_Tasks_Invoke_task_variable_dtor+0x34> <== NOT EXECUTED value = *tvp->ptr; *tvp->ptr = tvp->gval; } else { value = tvp->tval; 10ef2e: 8b 73 0c mov 0xc(%ebx),%esi <== NOT EXECUTED } if ( dtor ) 10ef31: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ef33: 74 09 je 10ef3e <_RTEMS_Tasks_Invoke_task_variable_dtor+0x26> <== NOT EXECUTED (*dtor)(value); 10ef35: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ef38: 56 push %esi <== NOT EXECUTED 10ef39: ff d1 call *%ecx <== NOT EXECUTED 10ef3b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Workspace_Free(tvp); 10ef3e: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 10ef41: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ef44: 5b pop %ebx <== NOT EXECUTED 10ef45: 5e pop %esi <== NOT EXECUTED 10ef46: c9 leave <== NOT EXECUTED } if ( dtor ) (*dtor)(value); _Workspace_Free(tvp); 10ef47: e9 78 e4 ff ff jmp 10d3c4 <_Workspace_Free> <== NOT EXECUTED void (*dtor)(void *); void *value; dtor = tvp->dtor; if (_Thread_Is_executing(the_thread)) { value = *tvp->ptr; 10ef4c: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 10ef4f: 8b 32 mov (%edx),%esi <== NOT EXECUTED *tvp->ptr = tvp->gval; 10ef51: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10ef54: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10ef56: eb d9 jmp 10ef31 <_RTEMS_Tasks_Invoke_task_variable_dtor+0x19> <== NOT EXECUTED 0010ee7c <_RTEMS_tasks_Create_extension>: bool _RTEMS_tasks_Create_extension( Thread_Control *executing, Thread_Control *created ) { 10ee7c: 55 push %ebp <== NOT EXECUTED 10ee7d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ee7f: 53 push %ebx <== NOT EXECUTED 10ee80: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ee83: 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() ) 10ee86: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10ee8b: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10ee8e: 80 78 04 01 cmpb $0x1,0x4(%eax) <== NOT EXECUTED 10ee92: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10ee94: 83 e0 c0 and $0xffffffc0,%eax <== NOT EXECUTED 10ee97: 83 c0 60 add $0x60,%eax <== NOT EXECUTED to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); 10ee9a: 50 push %eax <== NOT EXECUTED 10ee9b: e8 3c e5 ff ff call 10d3dc <_Workspace_Allocate> <== NOT EXECUTED 10eea0: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !api ) 10eea2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eea5: 85 c0 test %eax,%eax <== NOT EXECUTED 10eea7: 74 67 je 10ef10 <_RTEMS_tasks_Create_extension+0x94> <== NOT EXECUTED return false; created->API_Extensions[ THREAD_API_RTEMS ] = api; 10eea9: 89 83 f4 00 00 00 mov %eax,0xf4(%ebx) <== NOT EXECUTED api->pending_events = EVENT_SETS_NONE_PENDING; 10eeaf: 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 10eeb5: 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 10eeb9: 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. 10eec0: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) <== NOT EXECUTED * 10eec7: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10eece: 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 10eed5: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) <== NOT EXECUTED _ASR_Initialize( &api->Signal ); created->task_variables = NULL; 10eedc: c7 83 04 01 00 00 00 movl $0x0,0x104(%ebx) <== NOT EXECUTED 10eee3: 00 00 00 <== NOT EXECUTED if ( rtems_configuration_get_notepads_enabled() ) { 10eee6: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10eeeb: 8b 40 40 mov 0x40(%eax),%eax <== NOT EXECUTED 10eeee: 80 78 04 00 cmpb $0x0,0x4(%eax) <== NOT EXECUTED 10eef2: 74 12 je 10ef06 <_RTEMS_tasks_Create_extension+0x8a> <== NOT EXECUTED 10eef4: 31 c0 xor %eax,%eax <== NOT EXECUTED 10eef6: 66 90 xchg %ax,%ax <== NOT EXECUTED for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; 10eef8: c7 44 82 20 00 00 00 movl $0x0,0x20(%edx,%eax,4) <== NOT EXECUTED 10eeff: 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++) 10ef00: 40 inc %eax <== NOT EXECUTED 10ef01: 83 f8 10 cmp $0x10,%eax <== NOT EXECUTED 10ef04: 75 f2 jne 10eef8 <_RTEMS_tasks_Create_extension+0x7c> <== NOT EXECUTED 10ef06: b0 01 mov $0x1,%al <== NOT EXECUTED api->Notepads[i] = 0; } return true; } 10ef08: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ef0b: c9 leave <== NOT EXECUTED 10ef0c: c3 ret <== NOT EXECUTED 10ef0d: 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 ) 10ef10: 31 c0 xor %eax,%eax <== NOT EXECUTED for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; } return true; } 10ef12: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ef15: c9 leave <== NOT EXECUTED 10ef16: c3 ret <== NOT EXECUTED 0010ee28 <_RTEMS_tasks_Delete_extension>: User_extensions_routine _RTEMS_tasks_Delete_extension( Thread_Control *executing, Thread_Control *deleted ) { 10ee28: 55 push %ebp <== NOT EXECUTED 10ee29: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ee2b: 56 push %esi <== NOT EXECUTED 10ee2c: 53 push %ebx <== NOT EXECUTED 10ee2d: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Free per task variable memory */ tvp = deleted->task_variables; 10ee30: 8b 86 04 01 00 00 mov 0x104(%esi),%eax <== NOT EXECUTED deleted->task_variables = NULL; 10ee36: c7 86 04 01 00 00 00 movl $0x0,0x104(%esi) <== NOT EXECUTED 10ee3d: 00 00 00 <== NOT EXECUTED while (tvp) { 10ee40: 85 c0 test %eax,%eax <== NOT EXECUTED 10ee42: 74 15 je 10ee59 <_RTEMS_tasks_Delete_extension+0x31> <== NOT EXECUTED next = (rtems_task_variable_t *)tvp->next; 10ee44: 8b 18 mov (%eax),%ebx <== NOT EXECUTED _RTEMS_Tasks_Invoke_task_variable_dtor( deleted, tvp ); 10ee46: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10ee49: 50 push %eax <== NOT EXECUTED 10ee4a: 56 push %esi <== NOT EXECUTED 10ee4b: e8 c8 00 00 00 call 10ef18 <_RTEMS_Tasks_Invoke_task_variable_dtor> <== NOT EXECUTED 10ee50: 89 d8 mov %ebx,%eax <== NOT EXECUTED * Free per task variable memory */ tvp = deleted->task_variables; deleted->task_variables = NULL; while (tvp) { 10ee52: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ee55: 85 db test %ebx,%ebx <== NOT EXECUTED 10ee57: 75 eb jne 10ee44 <_RTEMS_tasks_Delete_extension+0x1c> <== NOT EXECUTED /* * Free API specific memory */ (void) _Workspace_Free( deleted->API_Extensions[ THREAD_API_RTEMS ] ); 10ee59: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ee5c: ff b6 f4 00 00 00 pushl 0xf4(%esi) <== NOT EXECUTED 10ee62: e8 5d e5 ff ff call 10d3c4 <_Workspace_Free> <== NOT EXECUTED deleted->API_Extensions[ THREAD_API_RTEMS ] = NULL; 10ee67: c7 86 f4 00 00 00 00 movl $0x0,0xf4(%esi) <== NOT EXECUTED 10ee6e: 00 00 00 <== NOT EXECUTED 10ee71: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10ee74: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ee77: 5b pop %ebx <== NOT EXECUTED 10ee78: 5e pop %esi <== NOT EXECUTED 10ee79: c9 leave <== NOT EXECUTED 10ee7a: c3 ret <== NOT EXECUTED 0010ed70 <_RTEMS_tasks_Initialize_user_tasks>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks( void ) { 10ed70: 55 push %ebp <== NOT EXECUTED 10ed71: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( _RTEMS_tasks_Initialize_user_tasks_p ) 10ed73: 8b 0d 0c a5 11 00 mov 0x11a50c,%ecx <== NOT EXECUTED 10ed79: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ed7b: 74 03 je 10ed80 <_RTEMS_tasks_Initialize_user_tasks+0x10> <== NOT EXECUTED (*_RTEMS_tasks_Initialize_user_tasks_p)(); } 10ed7d: c9 leave <== NOT EXECUTED */ void _RTEMS_tasks_Initialize_user_tasks( void ) { if ( _RTEMS_tasks_Initialize_user_tasks_p ) (*_RTEMS_tasks_Initialize_user_tasks_p)(); 10ed7e: ff e1 jmp *%ecx <== NOT EXECUTED } 10ed80: c9 leave <== NOT EXECUTED 10ed81: 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 94 ea 11 00 mov 0x11ea94,%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 f9 0c 00 00 call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED 0010ed84 <_RTEMS_tasks_Manager_initialization>: */ void _RTEMS_tasks_Manager_initialization( uint32_t maximum_tasks ) { 10ed84: 55 push %ebp <== NOT EXECUTED 10ed85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ed87: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ed8a: 6a 04 push $0x4 <== NOT EXECUTED 10ed8c: 6a 00 push $0x0 <== NOT EXECUTED 10ed8e: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10ed93: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ed96: 6a 01 push $0x1 <== NOT EXECUTED 10ed98: 6a 02 push $0x2 <== NOT EXECUTED 10ed9a: 68 80 e9 11 00 push $0x11e980 <== NOT EXECUTED 10ed9f: e8 24 cd ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED /* * Add all the extensions for this API */ _User_extensions_Add_API_set( &_RTEMS_tasks_User_extensions ); 10eda4: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 10eda7: 68 80 c8 11 00 push $0x11c880 <== NOT EXECUTED 10edac: e8 73 0a 00 00 call 10f824 <_User_extensions_Add_API_set> <== NOT EXECUTED _API_extensions_Add( &_RTEMS_tasks_API_extensions ); 10edb1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10edb4: c7 45 08 60 c8 11 00 movl $0x11c860,0x8(%ebp) <== NOT EXECUTED MP_PACKET_TASKS, _RTEMS_tasks_MP_Process_packet ); #endif } 10edbb: 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 ); 10edbc: e9 8f be ff ff jmp 10ac50 <_API_extensions_Add> <== NOT EXECUTED 0010edc4 <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) { 10edc4: 55 push %ebp <== NOT EXECUTED 10edc5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10edc7: 57 push %edi <== NOT EXECUTED 10edc8: 56 push %esi <== NOT EXECUTED 10edc9: 53 push %ebx <== NOT EXECUTED 10edca: 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 ]; 10edcd: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10edd0: 8b b0 f4 00 00 00 mov 0xf4(%eax),%esi <== NOT EXECUTED if ( !api ) 10edd6: 85 f6 test %esi,%esi <== NOT EXECUTED 10edd8: 74 45 je 10ee1f <_RTEMS_tasks_Post_switch_extension+0x5b> <== NOT EXECUTED * Signal Processing */ asr = &api->Signal; _ISR_Disable( level ); 10edda: 9c pushf <== NOT EXECUTED 10eddb: fa cli <== NOT EXECUTED 10eddc: 58 pop %eax <== NOT EXECUTED signal_set = asr->signals_posted; 10eddd: 8b 7e 14 mov 0x14(%esi),%edi <== NOT EXECUTED asr->signals_posted = 0; 10ede0: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) <== NOT EXECUTED _ISR_Enable( level ); 10ede7: 50 push %eax <== NOT EXECUTED 10ede8: 9d popf <== NOT EXECUTED if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 10ede9: 85 ff test %edi,%edi <== NOT EXECUTED 10edeb: 74 32 je 10ee1f <_RTEMS_tasks_Post_switch_extension+0x5b> <== NOT EXECUTED return; asr->nest_level += 1; 10eded: ff 46 1c incl 0x1c(%esi) <== NOT EXECUTED rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10edf0: 50 push %eax <== NOT EXECUTED 10edf1: 8d 5d f0 lea -0x10(%ebp),%ebx <== NOT EXECUTED 10edf4: 53 push %ebx <== NOT EXECUTED 10edf5: 68 ff ff 00 00 push $0xffff <== NOT EXECUTED 10edfa: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 10edfd: e8 e6 0e 00 00 call 10fce8 <== NOT EXECUTED (*asr->handler)( signal_set ); 10ee02: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 10ee05: ff 56 0c call *0xc(%esi) <== NOT EXECUTED asr->nest_level -= 1; 10ee08: ff 4e 1c decl 0x1c(%esi) <== NOT EXECUTED rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10ee0b: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10ee0e: 53 push %ebx <== NOT EXECUTED 10ee0f: 68 ff ff 00 00 push $0xffff <== NOT EXECUTED 10ee14: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10ee17: e8 cc 0e 00 00 call 10fce8 <== NOT EXECUTED 10ee1c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10ee1f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ee22: 5b pop %ebx <== NOT EXECUTED 10ee23: 5e pop %esi <== NOT EXECUTED 10ee24: 5f pop %edi <== NOT EXECUTED 10ee25: c9 leave <== NOT EXECUTED 10ee26: c3 ret <== NOT EXECUTED 0010ed14 <_RTEMS_tasks_Start_extension>: User_extensions_routine _RTEMS_tasks_Start_extension( Thread_Control *executing, Thread_Control *started ) { 10ed14: 55 push %ebp <== NOT EXECUTED 10ed15: 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; 10ed17: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ed1a: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10ed20: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED } 10ed26: c9 leave <== NOT EXECUTED 10ed27: c3 ret <== NOT EXECUTED 0010ed28 <_RTEMS_tasks_Switch_extension>: void _RTEMS_tasks_Switch_extension( Thread_Control *executing, Thread_Control *heir ) { 10ed28: 55 push %ebp <== NOT EXECUTED 10ed29: 89 e5 mov %esp,%ebp <== NOT EXECUTED /* * Per Task Variables */ tvp = executing->task_variables; 10ed2b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ed2e: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx <== NOT EXECUTED while (tvp) { 10ed34: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ed36: 74 13 je 10ed4b <_RTEMS_tasks_Switch_extension+0x23> <== NOT EXECUTED tvp->tval = *tvp->ptr; 10ed38: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10ed3b: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10ed3d: 89 51 0c mov %edx,0xc(%ecx) <== NOT EXECUTED *tvp->ptr = tvp->gval; 10ed40: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED 10ed43: 89 10 mov %edx,(%eax) <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 10ed45: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 10ed47: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ed49: 75 ed jne 10ed38 <_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; 10ed4b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ed4e: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx <== NOT EXECUTED while (tvp) { 10ed54: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ed56: 74 13 je 10ed6b <_RTEMS_tasks_Switch_extension+0x43> <== NOT EXECUTED tvp->gval = *tvp->ptr; 10ed58: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10ed5b: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10ed5d: 89 51 08 mov %edx,0x8(%ecx) <== NOT EXECUTED *tvp->ptr = tvp->tval; 10ed60: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED 10ed63: 89 10 mov %edx,(%eax) <== NOT EXECUTED tvp = (rtems_task_variable_t *)tvp->next; 10ed65: 8b 09 mov (%ecx),%ecx <== NOT EXECUTED *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 10ed67: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10ed69: 75 ed jne 10ed58 <_RTEMS_tasks_Switch_extension+0x30> <== NOT EXECUTED tvp->gval = *tvp->ptr; *tvp->ptr = tvp->tval; tvp = (rtems_task_variable_t *)tvp->next; } } 10ed6b: c9 leave <== NOT EXECUTED 10ed6c: 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 6c 19 00 00 call 10ca30 <_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 3c 28 12 00 cmp 0x12283c,%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 44 28 12 00 push $0x122844 <== NOT EXECUTED 10b103: e8 04 39 00 00 call 10ea0c <_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 04 38 00 00 call 10e918 <_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 0010ec60 <_Rate_monotonic_Manager_initialization>: */ void _Rate_monotonic_Manager_initialization( uint32_t maximum_periods ) { 10ec60: 55 push %ebp <== NOT EXECUTED 10ec61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ec63: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ec66: 6a 04 push $0x4 <== NOT EXECUTED 10ec68: 6a 00 push $0x0 <== NOT EXECUTED 10ec6a: 68 8c 00 00 00 push $0x8c <== NOT EXECUTED 10ec6f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ec72: 6a 08 push $0x8 <== NOT EXECUTED 10ec74: 6a 02 push $0x2 <== NOT EXECUTED 10ec76: 68 80 ee 11 00 push $0x11ee80 <== NOT EXECUTED 10ec7b: e8 48 ce ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10ec80: 83 c4 20 add $0x20,%esp <== NOT EXECUTED , FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10ec83: c9 leave <== NOT EXECUTED 10ec84: 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 80 26 12 00 push $0x122680 <== NOT EXECUTED 10b6f3: e8 a4 1c 00 00 call 10d39c <_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 78 27 12 00 mov 0x122778,%eax <== NOT EXECUTED 10b71f: 48 dec %eax <== NOT EXECUTED 10b720: a3 78 27 12 00 mov %eax,0x122778 <== 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 f6 20 00 00 call 10d838 <_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 5c 28 12 00 push $0x12285c <== NOT EXECUTED 10b769: e8 46 35 00 00 call 10ecb4 <_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 ff 18 00 00 call 10ca30 <_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 bc 38 00 00 call 10ea0c <_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 3c 28 12 00 mov 0x12283c,%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 44 28 12 00 push $0x122844 <== NOT EXECUTED 10b174: e8 93 38 00 00 call 10ea0c <_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 93 37 00 00 call 10e918 <_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 57 38 00 00 call 10e9e8 <_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 60 38 00 00 call 10ea0c <_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 5d 37 00 00 call 10e918 <_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 1e 38 00 00 call 10e9e8 <_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 d7 37 00 00 call 10e9c4 <_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 05 37 00 00 call 10e918 <_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 c6 37 00 00 call 10e9e8 <_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 7f 37 00 00 call 10e9c4 <_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 0010ec88 <_Region_Manager_initialization>: */ void _Region_Manager_initialization( uint32_t maximum_regions ) { 10ec88: 55 push %ebp <== NOT EXECUTED 10ec89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ec8b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ec8e: 6a 04 push $0x4 <== NOT EXECUTED 10ec90: 6a 00 push $0x0 <== NOT EXECUTED 10ec92: 68 c0 00 00 00 push $0xc0 <== NOT EXECUTED 10ec97: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ec9a: 6a 06 push $0x6 <== NOT EXECUTED 10ec9c: 6a 02 push $0x2 <== NOT EXECUTED 10ec9e: 68 c0 ee 11 00 push $0x11eec0 <== NOT EXECUTED 10eca3: e8 20 ce ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10eca8: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_REGION, 0 /* XXX _Region_MP_Process_packet */ ); #endif } 10ecab: c9 leave <== NOT EXECUTED 10ecac: c3 ret <== NOT EXECUTED 0011a24c <_Region_Process_queue>: */ void _Region_Process_queue( Region_Control *the_region ) { 11a24c: 55 push %ebp <== NOT EXECUTED 11a24d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11a24f: 57 push %edi <== NOT EXECUTED 11a250: 56 push %esi <== NOT EXECUTED 11a251: 53 push %ebx <== NOT EXECUTED 11a252: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 11a255: 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 11a258: a1 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 11a25d: 40 inc %eax <== NOT EXECUTED 11a25e: a3 f8 5a 13 00 mov %eax,0x135af8 <== 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(); 11a263: ff 35 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 11a269: e8 c6 b1 ff ff call 115434 <_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 ); 11a26e: 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. * 11a271: 8d 46 68 lea 0x68(%esi),%eax <== NOT EXECUTED 11a274: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 11a277: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11a27a: eb 33 jmp 11a2af <_Region_Process_queue+0x63> <== NOT EXECUTED 11a27c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11a27f: ff 70 24 pushl 0x24(%eax) <== NOT EXECUTED 11a282: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 11a285: e8 9e bb ff ff call 115e28 <_Heap_Allocate> <== NOT EXECUTED 11a28a: 89 c2 mov %eax,%edx <== NOT EXECUTED the_segment = (void **) _Region_Allocate_segment( the_region, the_thread->Wait.count ); if ( the_segment == NULL ) 11a28c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11a28f: 85 c0 test %eax,%eax <== NOT EXECUTED 11a291: 74 2e je 11a2c1 <_Region_Process_queue+0x75> <== NOT EXECUTED break; *(void **)the_thread->Wait.return_argument = the_segment; 11a293: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 11a296: 89 10 mov %edx,(%eax) <== NOT EXECUTED the_region->number_of_used_blocks += 1; 11a298: ff 46 64 incl 0x64(%esi) <== NOT EXECUTED _Thread_queue_Extract( &the_region->Wait_queue, the_thread ); 11a29b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11a29e: 53 push %ebx <== NOT EXECUTED 11a29f: 57 push %edi <== NOT EXECUTED 11a2a0: e8 47 06 00 00 call 11a8ec <_Thread_queue_Extract> <== NOT EXECUTED the_thread->Wait.return_code = RTEMS_SUCCESSFUL; 11a2a5: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) <== NOT EXECUTED 11a2ac: 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 ); 11a2af: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11a2b2: 57 push %edi <== NOT EXECUTED 11a2b3: e8 28 07 00 00 call 11a9e0 <_Thread_queue_First> <== NOT EXECUTED 11a2b8: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( the_thread == NULL ) 11a2ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11a2bd: 85 c0 test %eax,%eax <== NOT EXECUTED 11a2bf: 75 bb jne 11a27c <_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(); } 11a2c1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11a2c4: 5b pop %ebx <== NOT EXECUTED 11a2c5: 5e pop %esi <== NOT EXECUTED 11a2c6: 5f pop %edi <== NOT EXECUTED 11a2c7: 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(); 11a2c8: e9 13 d1 ff ff jmp 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 0010ece8 <_Semaphore_Manager_initialization>: */ void _Semaphore_Manager_initialization( uint32_t maximum_semaphores ) { 10ece8: 55 push %ebp <== NOT EXECUTED 10ece9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eceb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ecee: 6a 04 push $0x4 <== NOT EXECUTED 10ecf0: 6a 00 push $0x0 <== NOT EXECUTED 10ecf2: 6a 78 push $0x78 <== NOT EXECUTED 10ecf4: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ecf7: 6a 03 push $0x3 <== NOT EXECUTED 10ecf9: 6a 02 push $0x2 <== NOT EXECUTED 10ecfb: 68 40 e9 11 00 push $0x11e940 <== NOT EXECUTED 10ed00: e8 c3 cd ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10ed05: 83 c4 20 add $0x20,%esp <== NOT EXECUTED MP_PACKET_SEMAPHORE, _Semaphore_MP_Process_packet ); #endif } 10ed08: c9 leave <== NOT EXECUTED 10ed09: 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 1c 85 11 00 mov 0x11851c(,%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 38 85 11 00 mov 0x118538(,%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 0010ed0c <_Signal_Manager_initialization>: * * Output parameters: NONE */ void _Signal_Manager_initialization( void ) { 10ed0c: 55 push %ebp <== NOT EXECUTED 10ed0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED _MPCI_Register_packet_processor( MP_PACKET_SIGNAL, _Signal_MP_Process_packet ); #endif } 10ed0f: c9 leave <== NOT EXECUTED 10ed10: c3 ret <== NOT EXECUTED 0010b1f8 <_TOD_Get>: */ void _TOD_Get( struct timespec *time ) { 10b1f8: 55 push %ebp <== NOT EXECUTED 10b1f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b1fb: 56 push %esi <== NOT EXECUTED 10b1fc: 53 push %ebx <== NOT EXECUTED 10b1fd: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10b200: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED ISR_Level level; struct timespec offset; /* assume time checked by caller */ offset.tv_sec = 0; 10b203: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED offset.tv_nsec = 0; 10b20a: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED /* _TOD_Now is a proper POSIX time */ _ISR_Disable( level ); 10b211: 9c pushf <== NOT EXECUTED 10b212: fa cli <== NOT EXECUTED 10b213: 5b pop %ebx <== NOT EXECUTED *time = _TOD_Now; 10b214: a1 8c ea 11 00 mov 0x11ea8c,%eax <== NOT EXECUTED 10b219: 8b 15 90 ea 11 00 mov 0x11ea90,%edx <== NOT EXECUTED 10b21f: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10b221: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED if ( _Watchdog_Nanoseconds_since_tick_handler ) 10b224: a1 c8 eb 11 00 mov 0x11ebc8,%eax <== NOT EXECUTED 10b229: 85 c0 test %eax,%eax <== NOT EXECUTED 10b22b: 74 05 je 10b232 <_TOD_Get+0x3a> <== NOT EXECUTED offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)(); 10b22d: ff d0 call *%eax <== NOT EXECUTED 10b22f: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED _ISR_Enable( level ); 10b232: 53 push %ebx <== NOT EXECUTED 10b233: 9d popf <== NOT EXECUTED _Timespec_Add_to( time, &offset ); 10b234: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b237: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b23a: 50 push %eax <== NOT EXECUTED 10b23b: 56 push %esi <== NOT EXECUTED 10b23c: e8 97 1c 00 00 call 10ced8 <_Timespec_Add_to> <== NOT EXECUTED 10b241: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10b244: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b247: 5b pop %ebx <== NOT EXECUTED 10b248: 5e pop %esi <== NOT EXECUTED 10b249: c9 leave <== NOT EXECUTED 10b24a: c3 ret <== NOT EXECUTED 0010f20c <_TOD_Get_uptime>: */ void _TOD_Get_uptime( struct timespec *uptime ) { 10f20c: 55 push %ebp <== NOT EXECUTED 10f20d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f20f: 56 push %esi <== NOT EXECUTED 10f210: 53 push %ebx <== NOT EXECUTED 10f211: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10f214: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED ISR_Level level; struct timespec offset; /* assume uptime checked by caller */ offset.tv_sec = 0; 10f217: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED offset.tv_nsec = 0; 10f21e: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) <== NOT EXECUTED _ISR_Disable( level ); 10f225: 9c pushf <== NOT EXECUTED 10f226: fa cli <== NOT EXECUTED 10f227: 5b pop %ebx <== NOT EXECUTED *uptime = _TOD_Uptime; 10f228: a1 78 ea 11 00 mov 0x11ea78,%eax <== NOT EXECUTED 10f22d: 8b 15 7c ea 11 00 mov 0x11ea7c,%edx <== NOT EXECUTED 10f233: 89 06 mov %eax,(%esi) <== NOT EXECUTED 10f235: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED if ( _Watchdog_Nanoseconds_since_tick_handler ) 10f238: a1 c8 eb 11 00 mov 0x11ebc8,%eax <== NOT EXECUTED 10f23d: 85 c0 test %eax,%eax <== NOT EXECUTED 10f23f: 74 05 je 10f246 <_TOD_Get_uptime+0x3a> <== NOT EXECUTED offset.tv_nsec = (*_Watchdog_Nanoseconds_since_tick_handler)(); 10f241: ff d0 call *%eax <== NOT EXECUTED 10f243: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED _ISR_Enable( level ); 10f246: 53 push %ebx <== NOT EXECUTED 10f247: 9d popf <== NOT EXECUTED _Timespec_Add_to( uptime, &offset ); 10f248: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f24b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10f24e: 50 push %eax <== NOT EXECUTED 10f24f: 56 push %esi <== NOT EXECUTED 10f250: e8 83 dc ff ff call 10ced8 <_Timespec_Add_to> <== NOT EXECUTED 10f255: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10f258: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f25b: 5b pop %ebx <== NOT EXECUTED 10f25c: 5e pop %esi <== NOT EXECUTED 10f25d: c9 leave <== NOT EXECUTED 10f25e: c3 ret <== NOT EXECUTED 0010b24c <_TOD_Handler_initialization>: */ void _TOD_Handler_initialization( uint32_t microseconds_per_tick ) { 10b24c: 55 push %ebp <== NOT EXECUTED 10b24d: 89 e5 mov %esp,%ebp <== NOT EXECUTED _TOD_Microseconds_per_tick = microseconds_per_tick; 10b24f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b252: a3 c0 eb 11 00 mov %eax,0x11ebc0 <== NOT EXECUTED /* POSIX format TOD (timespec) */ _TOD_Now.tv_sec = TOD_SECONDS_1970_THROUGH_1988; 10b257: c7 05 8c ea 11 00 00 movl $0x21dae500,0x11ea8c <== NOT EXECUTED 10b25e: e5 da 21 <== NOT EXECUTED _TOD_Now.tv_nsec = 0; 10b261: c7 05 90 ea 11 00 00 movl $0x0,0x11ea90 <== NOT EXECUTED 10b268: 00 00 00 <== NOT EXECUTED /* Uptime (timespec) */ _TOD_Uptime.tv_sec = 0; 10b26b: c7 05 78 ea 11 00 00 movl $0x0,0x11ea78 <== NOT EXECUTED 10b272: 00 00 00 <== NOT EXECUTED _TOD_Uptime.tv_nsec = 0; 10b275: c7 05 7c ea 11 00 00 movl $0x0,0x11ea7c <== NOT EXECUTED 10b27c: 00 00 00 <== NOT EXECUTED /* TOD has not been set */ _TOD_Is_set = FALSE; 10b27f: c6 05 0c ea 11 00 00 movb $0x0,0x11ea0c <== NOT EXECUTED _TOD_Activate(); } 10b286: c9 leave <== NOT EXECUTED 10b287: c3 ret <== NOT EXECUTED 0010c588 <_TOD_Set>: */ void _TOD_Set( const struct timespec *time ) { 10c588: 55 push %ebp <== NOT EXECUTED 10c589: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c58b: 53 push %ebx <== NOT EXECUTED 10c58c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10c58f: 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 10c592: a1 58 a5 12 00 mov 0x12a558,%eax <== NOT EXECUTED 10c597: 40 inc %eax <== NOT EXECUTED 10c598: a3 58 a5 12 00 mov %eax,0x12a558 <== NOT EXECUTED _Thread_Disable_dispatch(); _TOD_Deactivate(); if ( time->tv_sec < _TOD_Seconds_since_epoch ) 10c59d: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10c59f: a1 ec a5 12 00 mov 0x12a5ec,%eax <== NOT EXECUTED 10c5a4: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10c5a6: 7c 34 jl 10c5dc <_TOD_Set+0x54> <== NOT EXECUTED */ bool _Protected_heap_Free( Heap_Control *the_heap, void *start_address ); 10c5a8: 51 push %ecx <== NOT EXECUTED 10c5a9: 29 c2 sub %eax,%edx <== NOT EXECUTED 10c5ab: 52 push %edx <== NOT EXECUTED 10c5ac: 6a 00 push $0x0 <== NOT EXECUTED 10c5ae: 68 30 a6 12 00 push $0x12a630 <== NOT EXECUTED 10c5b3: e8 a8 23 00 00 call 10e960 <_Watchdog_Adjust> <== NOT EXECUTED 10c5b8: 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; 10c5bb: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10c5bd: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10c5c0: a3 f0 a5 12 00 mov %eax,0x12a5f0 <== NOT EXECUTED 10c5c5: 89 15 ec a5 12 00 mov %edx,0x12a5ec <== NOT EXECUTED _TOD_Is_set = TRUE; 10c5cb: c6 05 6c a5 12 00 01 movb $0x1,0x12a56c <== NOT EXECUTED _TOD_Activate(); _Thread_Enable_dispatch(); } 10c5d2: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c5d5: c9 leave <== NOT EXECUTED _TOD_Now = *time; _TOD_Is_set = TRUE; _TOD_Activate(); _Thread_Enable_dispatch(); 10c5d6: e9 99 11 00 00 jmp 10d774 <_Thread_Enable_dispatch> <== NOT EXECUTED 10c5db: 90 nop <== NOT EXECUTED 10c5dc: 51 push %ecx <== NOT EXECUTED 10c5dd: 29 d0 sub %edx,%eax <== NOT EXECUTED 10c5df: 50 push %eax <== NOT EXECUTED 10c5e0: 6a 01 push $0x1 <== NOT EXECUTED 10c5e2: 68 30 a6 12 00 push $0x12a630 <== NOT EXECUTED 10c5e7: e8 74 23 00 00 call 10e960 <_Watchdog_Adjust> <== NOT EXECUTED 10c5ec: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c5ef: eb ca jmp 10c5bb <_TOD_Set+0x33> <== NOT EXECUTED 0010b288 <_TOD_Tickle_ticks>: * * Output parameters: NONE */ void _TOD_Tickle_ticks( void ) { 10b288: 55 push %ebp <== NOT EXECUTED 10b289: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b28b: 53 push %ebx <== NOT EXECUTED 10b28c: 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; 10b28f: a1 c0 eb 11 00 mov 0x11ebc0,%eax <== NOT EXECUTED 10b294: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10b297: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10b29a: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 10b29d: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 10b2a0: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED tick.tv_sec = 0; 10b2a3: 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; 10b2aa: a1 64 eb 11 00 mov 0x11eb64,%eax <== NOT EXECUTED 10b2af: 40 inc %eax <== NOT EXECUTED 10b2b0: a3 64 eb 11 00 mov %eax,0x11eb64 <== NOT EXECUTED /* Update the timespec format uptime */ (void) _Timespec_Add_to( &_TOD_Uptime, &tick ); 10b2b5: 8d 5d f4 lea -0xc(%ebp),%ebx <== NOT EXECUTED 10b2b8: 53 push %ebx <== NOT EXECUTED 10b2b9: 68 78 ea 11 00 push $0x11ea78 <== NOT EXECUTED 10b2be: e8 15 1c 00 00 call 10ced8 <_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 ); 10b2c3: 58 pop %eax <== NOT EXECUTED 10b2c4: 5a pop %edx <== NOT EXECUTED 10b2c5: 53 push %ebx <== NOT EXECUTED 10b2c6: 68 8c ea 11 00 push $0x11ea8c <== NOT EXECUTED 10b2cb: e8 08 1c 00 00 call 10ced8 <_Timespec_Add_to> <== NOT EXECUTED 10b2d0: 89 c3 mov %eax,%ebx <== NOT EXECUTED while ( seconds ) { 10b2d2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b2d5: 85 c0 test %eax,%eax <== NOT EXECUTED 10b2d7: 74 16 je 10b2ef <_TOD_Tickle_ticks+0x67> <== NOT EXECUTED 10b2d9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 10b2dc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b2df: 68 d0 ea 11 00 push $0x11ead0 <== NOT EXECUTED 10b2e4: e8 6b 20 00 00 call 10d354 <_Watchdog_Tickle> <== NOT EXECUTED 10b2e9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b2ec: 4b dec %ebx <== NOT EXECUTED 10b2ed: 75 ed jne 10b2dc <_TOD_Tickle_ticks+0x54> <== NOT EXECUTED _Watchdog_Tickle_seconds(); seconds--; } } 10b2ef: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b2f2: c9 leave <== NOT EXECUTED 10b2f3: 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 40 b7 11 movzwl 0x11b740(%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 74 b7 11 movzwl 0x11b774(%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 5a b7 11 movzwl 0x11b75a(%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 20 a7 12 00 divl 0x12a720 <== 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 b4 b7 11 00 mov 0x11b7b4(,%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 80 b7 11 00 mov 0x11b780(,%eax,4),%eax <== NOT EXECUTED 10ad21: eb e8 jmp 10ad0b <_TOD_Validate+0x5b> <== NOT EXECUTED 0010bdcc <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10bdcc: 55 push %ebp <== NOT EXECUTED 10bdcd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bdcf: 57 push %edi <== NOT EXECUTED 10bdd0: 56 push %esi <== NOT EXECUTED 10bdd1: 53 push %ebx <== NOT EXECUTED 10bdd2: 83 ec 18 sub $0x18,%esp <== NOT EXECUTED 10bdd5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bdd8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10bddb: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10bdde: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED */ /* * Save original state */ original_state = the_thread->current_state; 10bde1: 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 ); 10bde4: 53 push %ebx <== NOT EXECUTED 10bde5: e8 4a 0e 00 00 call 10cc34 <_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 ) 10bdea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bded: 39 73 14 cmp %esi,0x14(%ebx) <== NOT EXECUTED 10bdf0: 74 0d je 10bdff <_Thread_Change_priority+0x33> <== NOT EXECUTED _Thread_Set_priority( the_thread, new_priority ); 10bdf2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10bdf5: 56 push %esi <== NOT EXECUTED 10bdf6: 53 push %ebx <== NOT EXECUTED 10bdf7: e8 f4 0c 00 00 call 10caf0 <_Thread_Set_priority> <== NOT EXECUTED 10bdfc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _ISR_Disable( level ); 10bdff: 9c pushf <== NOT EXECUTED 10be00: fa cli <== NOT EXECUTED 10be01: 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; 10be02: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED if ( state != STATES_TRANSIENT ) { 10be05: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10be08: 74 3a je 10be44 <_Thread_Change_priority+0x78> <== NOT EXECUTED /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10be0a: 83 e7 04 and $0x4,%edi <== NOT EXECUTED 10be0d: 75 08 jne 10be17 <_Thread_Change_priority+0x4b> <== NOT EXECUTED the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10be0f: 89 d0 mov %edx,%eax <== NOT EXECUTED 10be11: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 10be14: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _ISR_Enable( level ); 10be17: 56 push %esi <== NOT EXECUTED 10be18: 9d popf <== NOT EXECUTED if ( _States_Is_waiting_on_thread_queue( state ) ) { 10be19: 81 e2 e0 be 03 00 and $0x3bee0,%edx <== NOT EXECUTED 10be1f: 75 0b jne 10be2c <_Thread_Change_priority+0x60> <== NOT EXECUTED if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10be21: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10be24: 5b pop %ebx <== NOT EXECUTED 10be25: 5e pop %esi <== NOT EXECUTED 10be26: 5f pop %edi <== NOT EXECUTED 10be27: c9 leave <== NOT EXECUTED 10be28: c3 ret <== NOT EXECUTED 10be29: 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 ); 10be2c: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 10be2f: 8b 43 44 mov 0x44(%ebx),%eax <== NOT EXECUTED 10be32: 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 ); } 10be35: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10be38: 5b pop %ebx <== NOT EXECUTED 10be39: 5e pop %esi <== NOT EXECUTED 10be3a: 5f pop %edi <== NOT EXECUTED 10be3b: 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 ); 10be3c: e9 1b 0c 00 00 jmp 10ca5c <_Thread_queue_Requeue> <== NOT EXECUTED 10be41: 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 ) ) { 10be44: 83 e7 04 and $0x4,%edi <== NOT EXECUTED 10be47: 75 41 jne 10be8a <_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 ); 10be49: 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 10be50: 8b 93 90 00 00 00 mov 0x90(%ebx),%edx <== NOT EXECUTED 10be56: 66 8b 83 96 00 00 00 mov 0x96(%ebx),%ax <== NOT EXECUTED 10be5d: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10be60: 66 a1 b0 ea 11 00 mov 0x11eab0,%ax <== NOT EXECUTED 10be66: 0b 83 94 00 00 00 or 0x94(%ebx),%eax <== NOT EXECUTED 10be6c: 66 a3 b0 ea 11 00 mov %ax,0x11eab0 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); if ( prepend_it ) 10be72: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10be76: 74 70 je 10bee8 <_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 10be78: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax <== NOT EXECUTED 10be7e: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED 10be81: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10be83: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10be85: 89 13 mov %edx,(%ebx) <== NOT EXECUTED 10be87: 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 ); 10be8a: 56 push %esi <== NOT EXECUTED 10be8b: 9d popf <== NOT EXECUTED 10be8c: fa cli <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10be8d: 66 8b 0d b0 ea 11 00 mov 0x11eab0,%cx <== NOT EXECUTED 10be94: 31 d2 xor %edx,%edx <== NOT EXECUTED 10be96: 89 d0 mov %edx,%eax <== NOT EXECUTED 10be98: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10be9c: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10be9f: 66 8b 8c 00 40 eb 11 mov 0x11eb40(%eax,%eax,1),%cx <== NOT EXECUTED 10bea6: 00 <== NOT EXECUTED 10bea7: 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. 10beab: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10beae: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10beb1: 01 d0 add %edx,%eax <== NOT EXECUTED 10beb3: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10beb6: 8b 15 c0 e9 11 00 mov 0x11e9c0,%edx <== NOT EXECUTED 10bebc: 8b 04 82 mov (%edx,%eax,4),%eax <== NOT EXECUTED 10bebf: a3 88 ea 11 00 mov %eax,0x11ea88 <== NOT EXECUTED void *starting_address, size_t size ); /** * This function attempts to allocate a block of @a size bytes from 10bec4: 8b 15 bc ea 11 00 mov 0x11eabc,%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() && 10beca: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10becc: 74 0d je 10bedb <_Thread_Change_priority+0x10f> <== NOT EXECUTED 10bece: 80 7a 76 00 cmpb $0x0,0x76(%edx) <== NOT EXECUTED 10bed2: 74 07 je 10bedb <_Thread_Change_priority+0x10f> <== NOT EXECUTED _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; 10bed4: c6 05 cc ea 11 00 01 movb $0x1,0x11eacc <== NOT EXECUTED _ISR_Enable( level ); 10bedb: 56 push %esi <== NOT EXECUTED 10bedc: 9d popf <== NOT EXECUTED } 10bedd: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10bee0: 5b pop %ebx <== NOT EXECUTED 10bee1: 5e pop %esi <== NOT EXECUTED 10bee2: 5f pop %edi <== NOT EXECUTED 10bee3: c9 leave <== NOT EXECUTED 10bee4: c3 ret <== NOT EXECUTED 10bee5: 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 ); 10bee8: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax <== NOT EXECUTED 10beee: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10bef1: 89 13 mov %edx,(%ebx) <== NOT EXECUTED 10bef3: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10bef6: 89 58 08 mov %ebx,0x8(%eax) <== NOT EXECUTED 10bef9: 89 1a mov %ebx,(%edx) <== NOT EXECUTED 10befb: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 10befe: eb 8a jmp 10be8a <_Thread_Change_priority+0xbe> <== NOT EXECUTED 0010bf00 <_Thread_Clear_state>: void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 10bf00: 55 push %ebp <== NOT EXECUTED 10bf01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf03: 53 push %ebx <== NOT EXECUTED 10bf04: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10bf07: 9c pushf <== NOT EXECUTED 10bf08: fa cli <== NOT EXECUTED 10bf09: 5b pop %ebx <== NOT EXECUTED current_state = the_thread->current_state; 10bf0a: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED if ( current_state & state ) { 10bf0d: 85 55 0c test %edx,0xc(%ebp) <== NOT EXECUTED 10bf10: 74 72 je 10bf84 <_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( 10bf12: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10bf15: f7 d0 not %eax <== NOT EXECUTED 10bf17: 21 d0 and %edx,%eax <== NOT EXECUTED current_state = 10bf19: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED the_thread->current_state = _States_Clear( state, current_state ); if ( _States_Is_ready( current_state ) ) { 10bf1c: 85 c0 test %eax,%eax <== NOT EXECUTED 10bf1e: 75 64 jne 10bf84 <_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 10bf20: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10bf26: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10bf2d: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10bf30: 66 a1 b0 ea 11 00 mov 0x11eab0,%ax <== NOT EXECUTED 10bf36: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10bf3c: 66 a3 b0 ea 11 00 mov %ax,0x11eab0 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10bf42: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10bf48: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10bf4b: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10bf4d: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10bf50: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10bf53: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10bf55: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10bf58: 53 push %ebx <== NOT EXECUTED 10bf59: 9d popf <== NOT EXECUTED 10bf5a: 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 ) { 10bf5b: 8b 51 14 mov 0x14(%ecx),%edx <== NOT EXECUTED 10bf5e: a1 88 ea 11 00 mov 0x11ea88,%eax <== NOT EXECUTED 10bf63: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10bf66: 73 1c jae 10bf84 <_Thread_Clear_state+0x84> <== NOT EXECUTED _Thread_Heir = the_thread; 10bf68: 89 0d 88 ea 11 00 mov %ecx,0x11ea88 <== NOT EXECUTED if ( _Thread_Executing->is_preemptible || 10bf6e: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED 10bf73: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10bf77: 75 04 jne 10bf7d <_Thread_Clear_state+0x7d> <== NOT EXECUTED 10bf79: 85 d2 test %edx,%edx <== NOT EXECUTED 10bf7b: 75 07 jne 10bf84 <_Thread_Clear_state+0x84> <== NOT EXECUTED the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10bf7d: c6 05 cc ea 11 00 01 movb $0x1,0x11eacc <== NOT EXECUTED } } } _ISR_Enable( level ); 10bf84: 53 push %ebx <== NOT EXECUTED 10bf85: 9d popf <== NOT EXECUTED } 10bf86: 5b pop %ebx <== NOT EXECUTED 10bf87: c9 leave <== NOT EXECUTED 10bf88: c3 ret <== NOT EXECUTED 0010bf8c <_Thread_Close>: void _Thread_Close( Objects_Information *information, Thread_Control *the_thread ) { 10bf8c: 55 push %ebp <== NOT EXECUTED 10bf8d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bf8f: 56 push %esi <== NOT EXECUTED 10bf90: 53 push %ebx <== NOT EXECUTED 10bf91: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10bf94: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10bf97: 0f b7 56 08 movzwl 0x8(%esi),%edx <== NOT EXECUTED 10bf9b: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10bf9e: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) <== NOT EXECUTED 10bfa5: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10bfaa: 48 dec %eax <== NOT EXECUTED 10bfab: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED * disappear and set a transient state on it. So we temporarily * unnest dispatching. */ _Thread_Unnest_dispatch(); _User_extensions_Thread_delete( the_thread ); 10bfb0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bfb3: 56 push %esi <== NOT EXECUTED 10bfb4: e8 3f 11 00 00 call 10d0f8 <_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 10bfb9: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10bfbe: 40 inc %eax <== NOT EXECUTED 10bfbf: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== 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 ); 10bfc4: 59 pop %ecx <== NOT EXECUTED 10bfc5: 58 pop %eax <== NOT EXECUTED 10bfc6: 56 push %esi <== NOT EXECUTED 10bfc7: 53 push %ebx <== NOT EXECUTED 10bfc8: e8 23 f6 ff ff call 10b5f0 <_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 ); 10bfcd: 58 pop %eax <== NOT EXECUTED 10bfce: 5a pop %edx <== NOT EXECUTED 10bfcf: 6a 01 push $0x1 <== NOT EXECUTED 10bfd1: 56 push %esi <== NOT EXECUTED 10bfd2: e8 85 0b 00 00 call 10cb5c <_Thread_Set_state> <== NOT EXECUTED if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 10bfd7: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 10bfda: e8 a5 09 00 00 call 10c984 <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 10bfdf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bfe2: 84 c0 test %al,%al <== NOT EXECUTED 10bfe4: 75 06 jne 10bfec <_Thread_Close+0x60> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 10bfe6: 83 7e 50 02 cmpl $0x2,0x50(%esi) <== NOT EXECUTED 10bfea: 74 68 je 10c054 <_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 ) ) 10bfec: 3b 35 80 ea 11 00 cmp 0x11ea80,%esi <== NOT EXECUTED 10bff2: 74 74 je 10c068 <_Thread_Close+0xdc> <== NOT EXECUTED _Thread_Deallocate_fp(); #endif the_thread->fp_context = NULL; 10bff4: c7 86 ec 00 00 00 00 movl $0x0,0xec(%esi) <== NOT EXECUTED 10bffb: 00 00 00 <== NOT EXECUTED if ( the_thread->Start.fp_context ) 10bffe: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED 10c004: 85 c0 test %eax,%eax <== NOT EXECUTED 10c006: 74 0c je 10c014 <_Thread_Close+0x88> <== NOT EXECUTED (void) _Workspace_Free( the_thread->Start.fp_context ); 10c008: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c00b: 50 push %eax <== NOT EXECUTED 10c00c: e8 b3 13 00 00 call 10d3c4 <_Workspace_Free> <== NOT EXECUTED 10c011: 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 ); 10c014: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c017: 56 push %esi <== NOT EXECUTED 10c018: e8 ef 0c 00 00 call 10cd0c <_Thread_Stack_Free> <== NOT EXECUTED the_thread->Start.stack = NULL; 10c01d: c7 86 d0 00 00 00 00 movl $0x0,0xd0(%esi) <== NOT EXECUTED 10c024: 00 00 00 <== NOT EXECUTED if ( the_thread->extensions ) 10c027: 8b 86 00 01 00 00 mov 0x100(%esi),%eax <== NOT EXECUTED 10c02d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c030: 85 c0 test %eax,%eax <== NOT EXECUTED 10c032: 74 0c je 10c040 <_Thread_Close+0xb4> <== NOT EXECUTED (void) _Workspace_Free( the_thread->extensions ); 10c034: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c037: 50 push %eax <== NOT EXECUTED 10c038: e8 87 13 00 00 call 10d3c4 <_Workspace_Free> <== NOT EXECUTED 10c03d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED the_thread->extensions = NULL; 10c040: c7 86 00 01 00 00 00 movl $0x0,0x100(%esi) <== NOT EXECUTED 10c047: 00 00 00 <== NOT EXECUTED } 10c04a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c04d: 5b pop %ebx <== NOT EXECUTED 10c04e: 5e pop %esi <== NOT EXECUTED 10c04f: c9 leave <== NOT EXECUTED 10c050: c3 ret <== NOT EXECUTED 10c051: 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 ); 10c054: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c057: 8d 46 48 lea 0x48(%esi),%eax <== NOT EXECUTED 10c05a: 50 push %eax <== NOT EXECUTED 10c05b: e8 88 12 00 00 call 10d2e8 <_Watchdog_Remove> <== NOT EXECUTED 10c060: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c063: eb 87 jmp 10bfec <_Thread_Close+0x60> <== NOT EXECUTED 10c065: 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( 10c068: c7 05 80 ea 11 00 00 movl $0x0,0x11ea80 <== NOT EXECUTED 10c06f: 00 00 00 <== NOT EXECUTED 10c072: eb 80 jmp 10bff4 <_Thread_Close+0x68> <== NOT EXECUTED 0010c074 <_Thread_Create_idle>: * * _Thread_Create_idle */ void _Thread_Create_idle( void ) { 10c074: 55 push %ebp <== NOT EXECUTED 10c075: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c077: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10c07a: 68 80 eb 11 00 push $0x11eb80 <== NOT EXECUTED 10c07f: e8 ec f4 ff ff call 10b570 <_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(); 10c084: a3 cc eb 11 00 mov %eax,0x11ebcc <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10c089: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10c08e: 40 inc %eax <== NOT EXECUTED 10c08f: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED * that when _Thread_Initialize unnests dispatch that we do not * do anything stupid. */ _Thread_Disable_dispatch(); _Thread_Initialize( 10c094: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10c099: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED 10c09c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c09f: 68 d0 85 11 00 push $0x1185d0 <== NOT EXECUTED 10c0a4: 6a 00 push $0x0 <== NOT EXECUTED 10c0a6: 6a 00 push $0x0 <== NOT EXECUTED 10c0a8: 6a 00 push $0x0 <== NOT EXECUTED 10c0aa: 6a 01 push $0x1 <== NOT EXECUTED 10c0ac: 0f b6 05 b4 a4 11 00 movzbl 0x11a4b4,%eax <== NOT EXECUTED 10c0b3: 50 push %eax <== NOT EXECUTED 10c0b4: 6a 00 push $0x0 <== NOT EXECUTED 10c0b6: a1 b0 a4 11 00 mov 0x11a4b0,%eax <== NOT EXECUTED 10c0bb: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10c0bd: 73 02 jae 10c0c1 <_Thread_Create_idle+0x4d> <== NOT EXECUTED 10c0bf: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c0c1: 50 push %eax <== NOT EXECUTED 10c0c2: 6a 00 push $0x0 <== NOT EXECUTED 10c0c4: ff 35 cc eb 11 00 pushl 0x11ebcc <== NOT EXECUTED 10c0ca: 68 80 eb 11 00 push $0x11eb80 <== NOT EXECUTED 10c0cf: e8 78 02 00 00 call 10c34c <_Thread_Initialize> <== NOT EXECUTED 10c0d4: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10c0d9: 48 dec %eax <== NOT EXECUTED 10c0da: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 10c0df: 8b 15 cc eb 11 00 mov 0x11ebcc,%edx <== NOT EXECUTED 10c0e5: 89 15 bc ea 11 00 mov %edx,0x11eabc <== NOT EXECUTED 10c0eb: 89 15 88 ea 11 00 mov %edx,0x11ea88 <== NOT EXECUTED _Thread_Executing = _Thread_Idle; _Thread_Start( 10c0f1: 83 c4 24 add $0x24,%esp <== NOT EXECUTED 10c0f4: 6a 00 push $0x0 <== NOT EXECUTED 10c0f6: 6a 00 push $0x0 <== NOT EXECUTED 10c0f8: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10c0fd: ff 70 14 pushl 0x14(%eax) <== NOT EXECUTED 10c100: 6a 00 push $0x0 <== NOT EXECUTED 10c102: 52 push %edx <== NOT EXECUTED 10c103: e8 9c 0c 00 00 call 10cda4 <_Thread_Start> <== NOT EXECUTED 10c108: 83 c4 20 add $0x20,%esp <== NOT EXECUTED _Configuration_Table->idle_task, NULL, 0 ); } 10c10b: c9 leave <== NOT EXECUTED 10c10c: c3 ret <== NOT EXECUTED 0010c110 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 10c110: 55 push %ebp <== NOT EXECUTED 10c111: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c113: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c116: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10c119: 50 push %eax <== NOT EXECUTED 10c11a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c11d: e8 aa 01 00 00 call 10c2cc <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10c122: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c125: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10c128: 85 d2 test %edx,%edx <== NOT EXECUTED 10c12a: 75 1c jne 10c148 <_Thread_Delay_ended+0x38> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10c12c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c12f: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10c134: 50 push %eax <== NOT EXECUTED 10c135: e8 c6 fd ff ff call 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 10c13a: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10c13f: 48 dec %eax <== NOT EXECUTED 10c140: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED 10c145: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_LOCAL: _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; } } 10c148: c9 leave <== NOT EXECUTED 10c149: c3 ret <== NOT EXECUTED 0010c14c <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10c14c: 55 push %ebp <== NOT EXECUTED 10c14d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c14f: 57 push %edi <== NOT EXECUTED 10c150: 56 push %esi <== NOT EXECUTED 10c151: 53 push %ebx <== NOT EXECUTED 10c152: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10c155: 8b 35 bc ea 11 00 mov 0x11eabc,%esi <== NOT EXECUTED _ISR_Disable( level ); 10c15b: 9c pushf <== NOT EXECUTED 10c15c: fa cli <== NOT EXECUTED 10c15d: 5a pop %edx <== NOT EXECUTED while ( _Context_Switch_necessary == TRUE ) { 10c15e: a0 cc ea 11 00 mov 0x11eacc,%al <== NOT EXECUTED 10c163: 84 c0 test %al,%al <== NOT EXECUTED 10c165: 0f 84 11 01 00 00 je 10c27c <_Thread_Dispatch+0x130> <== NOT EXECUTED 10c16b: 8d 7d e4 lea -0x1c(%ebp),%edi <== NOT EXECUTED 10c16e: e9 d2 00 00 00 jmp 10c245 <_Thread_Dispatch+0xf9> <== NOT EXECUTED 10c173: 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 ); 10c174: 52 push %edx <== NOT EXECUTED 10c175: 9d popf <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec uptime, ran; _TOD_Get_uptime( &uptime ); 10c176: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c179: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10c17c: 50 push %eax <== NOT EXECUTED 10c17d: e8 8a 30 00 00 call 10f20c <_TOD_Get_uptime> <== NOT EXECUTED _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 10c182: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c185: 57 push %edi <== NOT EXECUTED 10c186: 8d 45 ec lea -0x14(%ebp),%eax <== NOT EXECUTED 10c189: 50 push %eax <== NOT EXECUTED 10c18a: 68 c4 ea 11 00 push $0x11eac4 <== NOT EXECUTED 10c18f: e8 7c 0d 00 00 call 10cf10 <_Timespec_Subtract> <== NOT EXECUTED _Timespec_Add_to( &executing->cpu_time_used, &ran ); 10c194: 58 pop %eax <== NOT EXECUTED 10c195: 5a pop %edx <== NOT EXECUTED 10c196: 57 push %edi <== NOT EXECUTED 10c197: 8d 86 84 00 00 00 lea 0x84(%esi),%eax <== NOT EXECUTED 10c19d: 50 push %eax <== NOT EXECUTED 10c19e: e8 35 0d 00 00 call 10ced8 <_Timespec_Add_to> <== NOT EXECUTED _Thread_Time_of_last_context_switch = uptime; 10c1a3: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10c1a6: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10c1a9: a3 c4 ea 11 00 mov %eax,0x11eac4 <== NOT EXECUTED 10c1ae: 89 15 c8 ea 11 00 mov %edx,0x11eac8 <== NOT EXECUTED #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10c1b4: 8b 15 84 ea 11 00 mov 0x11ea84,%edx <== NOT EXECUTED 10c1ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c1bd: 85 d2 test %edx,%edx <== NOT EXECUTED 10c1bf: 74 10 je 10c1d1 <_Thread_Dispatch+0x85> <== NOT EXECUTED executing->libc_reent = *_Thread_libc_reent; 10c1c1: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10c1c3: 89 86 f0 00 00 00 mov %eax,0xf0(%esi) <== NOT EXECUTED *_Thread_libc_reent = heir->libc_reent; 10c1c9: 8b 83 f0 00 00 00 mov 0xf0(%ebx),%eax <== NOT EXECUTED 10c1cf: 89 02 mov %eax,(%edx) <== NOT EXECUTED } _User_extensions_Thread_switch( executing, heir ); 10c1d1: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c1d4: 53 push %ebx <== NOT EXECUTED 10c1d5: 56 push %esi <== NOT EXECUTED 10c1d6: e8 9d 0f 00 00 call 10d178 <_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 ); 10c1db: 59 pop %ecx <== NOT EXECUTED 10c1dc: 58 pop %eax <== NOT EXECUTED 10c1dd: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax <== NOT EXECUTED 10c1e3: 50 push %eax <== NOT EXECUTED 10c1e4: 8d 86 d4 00 00 00 lea 0xd4(%esi),%eax <== NOT EXECUTED 10c1ea: 50 push %eax <== NOT EXECUTED 10c1eb: e8 90 12 00 00 call 10d480 <_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) && 10c1f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c1f3: 8b 96 ec 00 00 00 mov 0xec(%esi),%edx <== NOT EXECUTED 10c1f9: 85 d2 test %edx,%edx <== NOT EXECUTED 10c1fb: 74 36 je 10c233 <_Thread_Dispatch+0xe7> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10c1fd: a1 80 ea 11 00 mov 0x11ea80,%eax <== NOT EXECUTED 10c202: 39 c6 cmp %eax,%esi <== NOT EXECUTED 10c204: 74 2d je 10c233 <_Thread_Dispatch+0xe7> <== NOT EXECUTED !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10c206: 85 c0 test %eax,%eax <== NOT EXECUTED 10c208: 74 11 je 10c21b <_Thread_Dispatch+0xcf> <== NOT EXECUTED _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10c20a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c20d: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10c212: 50 push %eax <== NOT EXECUTED 10c213: e8 9c 12 00 00 call 10d4b4 <_CPU_Context_save_fp> <== NOT EXECUTED 10c218: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Context_Restore_fp( &executing->fp_context ); 10c21b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c21e: 8d 86 ec 00 00 00 lea 0xec(%esi),%eax <== NOT EXECUTED 10c224: 50 push %eax <== NOT EXECUTED 10c225: e8 94 12 00 00 call 10d4be <_CPU_Context_restore_fp> <== NOT EXECUTED _Thread_Allocated_fp = executing; 10c22a: 89 35 80 ea 11 00 mov %esi,0x11ea80 <== NOT EXECUTED 10c230: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10c233: 8b 35 bc ea 11 00 mov 0x11eabc,%esi <== NOT EXECUTED _ISR_Disable( level ); 10c239: 9c pushf <== NOT EXECUTED 10c23a: fa cli <== NOT EXECUTED 10c23b: 5a pop %edx <== NOT EXECUTED Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Context_Switch_necessary == TRUE ) { 10c23c: a0 cc ea 11 00 mov 0x11eacc,%al <== NOT EXECUTED 10c241: 84 c0 test %al,%al <== NOT EXECUTED 10c243: 74 37 je 10c27c <_Thread_Dispatch+0x130> <== NOT EXECUTED heir = _Thread_Heir; 10c245: 8b 1d 88 ea 11 00 mov 0x11ea88,%ebx <== NOT EXECUTED _Thread_Dispatch_disable_level = 1; 10c24b: c7 05 f8 e9 11 00 01 movl $0x1,0x11e9f8 <== NOT EXECUTED 10c252: 00 00 00 <== NOT EXECUTED _Context_Switch_necessary = FALSE; 10c255: c6 05 cc ea 11 00 00 movb $0x0,0x11eacc <== NOT EXECUTED _Thread_Executing = heir; 10c25c: 89 1d bc ea 11 00 mov %ebx,0x11eabc <== 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 ) 10c262: 83 7b 7c 01 cmpl $0x1,0x7c(%ebx) <== NOT EXECUTED 10c266: 0f 85 08 ff ff ff jne 10c174 <_Thread_Dispatch+0x28> <== NOT EXECUTED heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c26c: a1 c4 e9 11 00 mov 0x11e9c4,%eax <== NOT EXECUTED 10c271: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10c274: e9 fb fe ff ff jmp 10c174 <_Thread_Dispatch+0x28> <== NOT EXECUTED 10c279: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED executing = _Thread_Executing; _ISR_Disable( level ); } _Thread_Dispatch_disable_level = 0; 10c27c: c7 05 f8 e9 11 00 00 movl $0x0,0x11e9f8 <== NOT EXECUTED 10c283: 00 00 00 <== NOT EXECUTED _ISR_Enable( level ); 10c286: 52 push %edx <== NOT EXECUTED 10c287: 9d popf <== NOT EXECUTED if ( _Thread_Do_post_task_switch_extension || 10c288: a1 a0 ea 11 00 mov 0x11eaa0,%eax <== NOT EXECUTED 10c28d: 85 c0 test %eax,%eax <== NOT EXECUTED 10c28f: 75 06 jne 10c297 <_Thread_Dispatch+0x14b> <== NOT EXECUTED 10c291: 80 7e 75 00 cmpb $0x0,0x75(%esi) <== NOT EXECUTED 10c295: 74 09 je 10c2a0 <_Thread_Dispatch+0x154> <== NOT EXECUTED executing->do_post_task_switch_extension ) { executing->do_post_task_switch_extension = false; 10c297: c6 46 75 00 movb $0x0,0x75(%esi) <== NOT EXECUTED _API_extensions_Run_postswitch(); 10c29b: e8 74 e9 ff ff call 10ac14 <_API_extensions_Run_postswitch> <== NOT EXECUTED } } 10c2a0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c2a3: 5b pop %ebx <== NOT EXECUTED 10c2a4: 5e pop %esi <== NOT EXECUTED 10c2a5: 5f pop %edi <== NOT EXECUTED 10c2a6: c9 leave <== NOT EXECUTED 10c2a7: c3 ret <== NOT EXECUTED 0010c2a8 <_Thread_Enable_dispatch>: */ #if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \ (__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) ) void _Thread_Enable_dispatch( void ) { 10c2a8: 55 push %ebp <== NOT EXECUTED 10c2a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED if ( --_Thread_Dispatch_disable_level ) 10c2ab: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10c2b0: 48 dec %eax <== NOT EXECUTED 10c2b1: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED 10c2b6: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10c2bb: 85 c0 test %eax,%eax <== NOT EXECUTED 10c2bd: 74 05 je 10c2c4 <_Thread_Enable_dispatch+0x1c> <== NOT EXECUTED return; _Thread_Dispatch(); } 10c2bf: c9 leave <== NOT EXECUTED 10c2c0: c3 ret <== NOT EXECUTED 10c2c1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10c2c4: 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(); 10c2c5: e9 82 fe ff ff jmp 10c14c <_Thread_Dispatch> <== NOT EXECUTED 0010ff80 <_Thread_Evaluate_mode>: * * XXX */ bool _Thread_Evaluate_mode( void ) { 10ff80: 55 push %ebp <== NOT EXECUTED 10ff81: 89 e5 mov %esp,%ebp <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 10ff83: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED if ( !_States_Is_ready( executing->current_state ) || 10ff88: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 10ff8b: 85 d2 test %edx,%edx <== NOT EXECUTED 10ff8d: 75 0e jne 10ff9d <_Thread_Evaluate_mode+0x1d> <== NOT EXECUTED 10ff8f: 3b 05 88 ea 11 00 cmp 0x11ea88,%eax <== NOT EXECUTED 10ff95: 74 11 je 10ffa8 <_Thread_Evaluate_mode+0x28> <== NOT EXECUTED 10ff97: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10ff9b: 74 0b je 10ffa8 <_Thread_Evaluate_mode+0x28> <== NOT EXECUTED ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; 10ff9d: c6 05 cc ea 11 00 01 movb $0x1,0x11eacc <== NOT EXECUTED 10ffa4: b0 01 mov $0x1,%al <== NOT EXECUTED return TRUE; } return FALSE; } 10ffa6: c9 leave <== NOT EXECUTED 10ffa7: 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; 10ffa8: 31 c0 xor %eax,%eax <== NOT EXECUTED } return FALSE; } 10ffaa: c9 leave <== NOT EXECUTED 10ffab: c3 ret <== NOT EXECUTED 0010c2cc <_Thread_Get>: Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) { 10c2cc: 55 push %ebp <== NOT EXECUTED 10c2cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c2cf: 53 push %ebx <== NOT EXECUTED 10c2d0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10c2d3: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c2d6: 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 ) ) { 10c2d9: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10c2db: 74 4b je 10c328 <_Thread_Get+0x5c> <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10c2dd: 89 ca mov %ecx,%edx <== NOT EXECUTED 10c2df: c1 ea 18 shr $0x18,%edx <== NOT EXECUTED 10c2e2: 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. 10c2e5: 8d 42 ff lea -0x1(%edx),%eax <== NOT EXECUTED 10c2e8: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10c2eb: 77 2b ja 10c318 <_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 :) */ 10c2ed: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10c2ef: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED 10c2f2: 48 dec %eax <== NOT EXECUTED 10c2f3: 75 23 jne 10c318 <_Thread_Get+0x4c> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } api_information = _Objects_Information_table[ the_api ]; 10c2f5: 8b 04 95 cc e9 11 00 mov 0x11e9cc(,%edx,4),%eax <== NOT EXECUTED if ( !api_information ) { 10c2fc: 85 c0 test %eax,%eax <== NOT EXECUTED 10c2fe: 74 44 je 10c344 <_Thread_Get+0x78> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } information = api_information[ the_class ]; 10c300: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED if ( !information ) { 10c303: 85 c0 test %eax,%eax <== NOT EXECUTED 10c305: 74 3d je 10c344 <_Thread_Get+0x78> <== NOT EXECUTED *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 10c307: 52 push %edx <== NOT EXECUTED 10c308: 53 push %ebx <== NOT EXECUTED 10c309: 51 push %ecx <== NOT EXECUTED 10c30a: 50 push %eax <== NOT EXECUTED 10c30b: e8 54 f7 ff ff call 10ba64 <_Objects_Get> <== NOT EXECUTED 10c310: 83 c4 10 add $0x10,%esp <== NOT EXECUTED done: return tp; } 10c313: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c316: c9 leave <== NOT EXECUTED 10c317: c3 ret <== NOT EXECUTED goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ *location = OBJECTS_ERROR; 10c318: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 10c31e: 31 c0 xor %eax,%eax <== NOT EXECUTED tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10c320: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c323: c9 leave <== NOT EXECUTED 10c324: c3 ret <== NOT EXECUTED 10c325: 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 10c328: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10c32d: 40 inc %eax <== NOT EXECUTED 10c32e: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== 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; 10c333: c7 03 00 00 00 00 movl $0x0,(%ebx) <== NOT EXECUTED tp = _Thread_Executing; 10c339: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10c33e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c341: c9 leave <== NOT EXECUTED 10c342: c3 ret <== NOT EXECUTED 10c343: 90 nop <== NOT EXECUTED goto done; } information = api_information[ the_class ]; if ( !information ) { *location = OBJECTS_ERROR; 10c344: c7 03 01 00 00 00 movl $0x1,(%ebx) <== NOT EXECUTED 10c34a: eb d4 jmp 10c320 <_Thread_Get+0x54> <== NOT EXECUTED 0010ffac <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 10ffac: 55 push %ebp <== NOT EXECUTED 10ffad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ffaf: 53 push %ebx <== NOT EXECUTED 10ffb0: 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; 10ffb3: 8b 1d bc ea 11 00 mov 0x11eabc,%ebx <== NOT EXECUTED /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 10ffb9: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED _ISR_Set_level(level); 10ffbf: 85 c0 test %eax,%eax <== NOT EXECUTED 10ffc1: 0f 84 91 00 00 00 je 110058 <_Thread_Handler+0xac> <== NOT EXECUTED 10ffc7: fa cli <== NOT EXECUTED #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 10ffc8: a0 b8 e7 11 00 mov 0x11e7b8,%al <== NOT EXECUTED 10ffcd: 88 45 fb mov %al,-0x5(%ebp) <== NOT EXECUTED doneConstructors = 1; 10ffd0: c6 05 b8 e7 11 00 01 movb $0x1,0x11e7b8 <== 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 ) ) { 10ffd7: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax <== NOT EXECUTED 10ffdd: 85 c0 test %eax,%eax <== NOT EXECUTED 10ffdf: 74 24 je 110005 <_Thread_Handler+0x59> <== NOT EXECUTED Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10ffe1: a1 80 ea 11 00 mov 0x11ea80,%eax <== NOT EXECUTED 10ffe6: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10ffe8: 74 1b je 110005 <_Thread_Handler+0x59> <== NOT EXECUTED if ( _Thread_Allocated_fp != NULL ) 10ffea: 85 c0 test %eax,%eax <== NOT EXECUTED 10ffec: 74 11 je 10ffff <_Thread_Handler+0x53> <== NOT EXECUTED _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10ffee: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fff1: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10fff6: 50 push %eax <== NOT EXECUTED 10fff7: e8 b8 d4 ff ff call 10d4b4 <_CPU_Context_save_fp> <== NOT EXECUTED 10fffc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Allocated_fp = executing; 10ffff: 89 1d 80 ea 11 00 mov %ebx,0x11ea80 <== 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 ); 110005: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110008: 53 push %ebx <== NOT EXECUTED 110009: e8 e2 cf ff ff call 10cff0 <_User_extensions_Thread_begin> <== NOT EXECUTED /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 11000e: e8 95 c2 ff ff call 10c2a8 <_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) */ 110013: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110016: 80 7d fb 00 cmpb $0x0,-0x5(%ebp) <== NOT EXECUTED 11001a: 74 6c je 110088 <_Thread_Handler+0xdc> <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 11001c: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax <== NOT EXECUTED 110022: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 110025: 74 71 je 110098 <_Thread_Handler+0xec> <== NOT EXECUTED 110027: 73 37 jae 110060 <_Thread_Handler+0xb4> <== NOT EXECUTED case THREAD_START_NUMERIC: executing->Wait.return_argument = 110029: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11002c: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 110032: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 110038: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 11003b: 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 ); 11003e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110041: 53 push %ebx <== NOT EXECUTED 110042: e8 e5 cf ff ff call 10d02c <_User_extensions_Thread_exitted> <== NOT EXECUTED _Internal_error_Occurred( 110047: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 11004a: 6a 06 push $0x6 <== NOT EXECUTED 11004c: 6a 01 push $0x1 <== NOT EXECUTED 11004e: 6a 00 push $0x0 <== NOT EXECUTED 110050: e8 87 b4 ff ff call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED 110055: 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); 110058: fb sti <== NOT EXECUTED 110059: e9 6a ff ff ff jmp 10ffc8 <_Thread_Handler+0x1c> <== NOT EXECUTED 11005e: 66 90 xchg %ax,%ax <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 110060: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 110063: 74 4b je 1100b0 <_Thread_Handler+0x104> <== NOT EXECUTED 110065: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 110068: 75 d4 jne 11003e <_Thread_Handler+0x92> <== NOT EXECUTED executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 11006a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11006d: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 110073: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 110079: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 11007f: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 110082: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110085: eb b7 jmp 11003e <_Thread_Handler+0x92> <== NOT EXECUTED 110087: 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 (); 110088: e8 d3 6d 00 00 call 116e60 <__start_set_sysctl_set> <== NOT EXECUTED #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 11008d: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax <== NOT EXECUTED 110093: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 110096: 75 8f jne 110027 <_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 = 110098: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11009b: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 1100a1: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 1100a7: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 1100aa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1100ad: eb 8f jmp 11003e <_Thread_Handler+0x92> <== NOT EXECUTED 1100af: 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 = 1100b0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1100b3: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 1100b9: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 1100bf: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 1100c5: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 1100c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1100cb: e9 6e ff ff ff jmp 11003e <_Thread_Handler+0x92> <== NOT EXECUTED 0010c554 <_Thread_Handler_initialization>: #if defined(RTEMS_MULTIPROCESSING) , uint32_t maximum_proxies #endif ) { 10c554: 55 push %ebp <== NOT EXECUTED 10c555: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c557: 53 push %ebx <== NOT EXECUTED 10c558: 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) 10c55b: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10c560: 8b 58 20 mov 0x20(%eax),%ebx <== NOT EXECUTED 10c563: 85 db test %ebx,%ebx <== NOT EXECUTED 10c565: 0f 94 c2 sete %dl <== NOT EXECUTED 10c568: 8b 48 24 mov 0x24(%eax),%ecx <== NOT EXECUTED 10c56b: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10c56d: 0f 94 c0 sete %al <== NOT EXECUTED 10c570: 38 c2 cmp %al,%dl <== NOT EXECUTED 10c572: 0f 85 a5 00 00 00 jne 10c61d <_Thread_Handler_initialization+0xc9> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_BAD_STACK_HOOK ); _Context_Switch_necessary = FALSE; 10c578: c6 05 cc ea 11 00 00 movb $0x0,0x11eacc <== NOT EXECUTED _Thread_Executing = NULL; 10c57f: c7 05 bc ea 11 00 00 movl $0x0,0x11eabc <== NOT EXECUTED 10c586: 00 00 00 <== NOT EXECUTED _Thread_Heir = NULL; 10c589: c7 05 88 ea 11 00 00 movl $0x0,0x11ea88 <== NOT EXECUTED 10c590: 00 00 00 <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) _Thread_Allocated_fp = NULL; 10c593: c7 05 80 ea 11 00 00 movl $0x0,0x11ea80 <== NOT EXECUTED 10c59a: 00 00 00 <== NOT EXECUTED #endif _Thread_Do_post_task_switch_extension = 0; 10c59d: c7 05 a0 ea 11 00 00 movl $0x0,0x11eaa0 <== NOT EXECUTED 10c5a4: 00 00 00 <== NOT EXECUTED _Thread_Maximum_extensions = maximum_extensions; 10c5a7: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c5aa: a3 9c ea 11 00 mov %eax,0x11ea9c <== NOT EXECUTED _Thread_Ticks_per_timeslice = ticks_per_timeslice; 10c5af: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c5b2: a3 c4 e9 11 00 mov %eax,0x11e9c4 <== NOT EXECUTED _Thread_Ready_chain = (Chain_Control *) _Workspace_Allocate_or_fatal_error( 10c5b7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c5ba: 0f b6 05 b4 a4 11 00 movzbl 0x11a4b4,%eax <== NOT EXECUTED 10c5c1: 8d 44 40 03 lea 0x3(%eax,%eax,2),%eax <== NOT EXECUTED 10c5c5: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10c5c8: 50 push %eax <== NOT EXECUTED 10c5c9: e8 26 0e 00 00 call 10d3f4 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10c5ce: a3 c0 e9 11 00 mov %eax,0x11e9c0 <== NOT EXECUTED (PRIORITY_MAXIMUM + 1) * sizeof(Chain_Control) ); for ( index=0; index <= PRIORITY_MAXIMUM ; index++ ) 10c5d3: 0f b6 1d b4 a4 11 00 movzbl 0x11a4b4,%ebx <== NOT EXECUTED 10c5da: 89 c2 mov %eax,%edx <== NOT EXECUTED 10c5dc: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10c5de: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c5e1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10c5e4: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10c5e7: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10c5e9: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10c5f0: 89 52 08 mov %edx,0x8(%edx) <== NOT EXECUTED 10c5f3: 41 inc %ecx <== NOT EXECUTED 10c5f4: 83 c2 0c add $0xc,%edx <== NOT EXECUTED 10c5f7: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 10c5f9: 76 e9 jbe 10c5e4 <_Thread_Handler_initialization+0x90> <== NOT EXECUTED /* * Initialize this class of objects. */ _Objects_Initialize_information( 10c5fb: 50 push %eax <== NOT EXECUTED 10c5fc: 6a 08 push $0x8 <== NOT EXECUTED 10c5fe: 6a 01 push $0x1 <== NOT EXECUTED 10c600: 68 08 01 00 00 push $0x108 <== NOT EXECUTED 10c605: 6a 01 push $0x1 <== NOT EXECUTED 10c607: 6a 01 push $0x1 <== NOT EXECUTED 10c609: 6a 01 push $0x1 <== NOT EXECUTED 10c60b: 68 80 eb 11 00 push $0x11eb80 <== NOT EXECUTED 10c610: e8 b3 f4 ff ff call 10bac8 <_Objects_Initialize_information> <== NOT EXECUTED 10c615: 83 c4 20 add $0x20,%esp <== NOT EXECUTED FALSE, /* TRUE if this is a global object class */ NULL /* Proxy extraction support callout */ #endif ); } 10c618: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c61b: c9 leave <== NOT EXECUTED 10c61c: 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( 10c61d: 52 push %edx <== NOT EXECUTED 10c61e: 6a 0f push $0xf <== NOT EXECUTED 10c620: 6a 01 push $0x1 <== NOT EXECUTED 10c622: 6a 00 push $0x0 <== NOT EXECUTED 10c624: e8 b3 ee ff ff call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED 0010c34c <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10c34c: 55 push %ebp <== NOT EXECUTED 10c34d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c34f: 57 push %edi <== NOT EXECUTED 10c350: 56 push %esi <== NOT EXECUTED 10c351: 53 push %ebx <== NOT EXECUTED 10c352: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c355: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10c358: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10c35b: 8a 45 18 mov 0x18(%ebp),%al <== NOT EXECUTED 10c35e: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED 10c361: 8a 4d 20 mov 0x20(%ebp),%cl <== NOT EXECUTED 10c364: 88 4d f2 mov %cl,-0xe(%ebp) <== NOT EXECUTED /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 10c367: 85 d2 test %edx,%edx <== NOT EXECUTED 10c369: 0f 84 b2 01 00 00 je 10c521 <_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; 10c36f: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx) <== NOT EXECUTED 10c376: 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 10c379: 89 93 c8 00 00 00 mov %edx,0xc8(%ebx) <== NOT EXECUTED * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 10c37f: 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 ) { 10c385: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) <== NOT EXECUTED 10c389: 0f 85 2d 01 00 00 jne 10c4bc <_Thread_Initialize+0x170> <== NOT EXECUTED fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) { _Thread_Stack_Free( the_thread ); return FALSE; 10c38f: 31 ff xor %edi,%edi <== NOT EXECUTED 10c391: 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; 10c393: 89 83 ec 00 00 00 mov %eax,0xec(%ebx) <== NOT EXECUTED the_thread->Start.fp_context = fp_area; 10c399: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) <== NOT EXECUTED * 10c39f: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10c3a6: 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 10c3ad: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) <== NOT EXECUTED * the heap 10c3b4: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED /* * Clear the libc reent hook. */ the_thread->libc_reent = NULL; 10c3bb: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx) <== NOT EXECUTED 10c3c2: 00 00 00 <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c3c5: a1 9c ea 11 00 mov 0x11ea9c,%eax <== NOT EXECUTED 10c3ca: 85 c0 test %eax,%eax <== NOT EXECUTED 10c3cc: 0f 85 06 01 00 00 jne 10c4d8 <_Thread_Initialize+0x18c> <== NOT EXECUTED return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 10c3d2: c7 83 00 01 00 00 00 movl $0x0,0x100(%ebx) <== NOT EXECUTED 10c3d9: 00 00 00 <== NOT EXECUTED 10c3dc: 31 f6 xor %esi,%esi <== NOT EXECUTED /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10c3de: 8a 45 f2 mov -0xe(%ebp),%al <== NOT EXECUTED 10c3e1: 88 83 ac 00 00 00 mov %al,0xac(%ebx) <== NOT EXECUTED the_thread->Start.budget_algorithm = budget_algorithm; 10c3e7: 8b 4d 24 mov 0x24(%ebp),%ecx <== NOT EXECUTED 10c3ea: 89 8b b0 00 00 00 mov %ecx,0xb0(%ebx) <== NOT EXECUTED the_thread->Start.budget_callout = budget_callout; 10c3f0: 8b 45 28 mov 0x28(%ebp),%eax <== NOT EXECUTED 10c3f3: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) <== NOT EXECUTED switch ( budget_algorithm ) { 10c3f9: 83 f9 02 cmp $0x2,%ecx <== NOT EXECUTED 10c3fc: 75 08 jne 10c406 <_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; 10c3fe: a1 c4 e9 11 00 mov 0x11e9c4,%eax <== NOT EXECUTED 10c403: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 10c406: 8b 4d 2c mov 0x2c(%ebp),%ecx <== NOT EXECUTED 10c409: 89 8b b8 00 00 00 mov %ecx,0xb8(%ebx) <== NOT EXECUTED the_thread->current_state = STATES_DORMANT; 10c40f: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) <== NOT EXECUTED the_thread->Wait.queue = NULL; 10c416: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED the_thread->resource_count = 0; 10c41d: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED the_thread->suspend_count = 0; 10c424: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED the_thread->real_priority = priority; 10c42b: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 10c42e: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED the_thread->Start.initial_priority = priority; 10c431: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) <== NOT EXECUTED _Thread_Set_priority( the_thread, priority ); 10c437: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c43a: 50 push %eax <== NOT EXECUTED 10c43b: 53 push %ebx <== NOT EXECUTED 10c43c: e8 af 06 00 00 call 10caf0 <_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; 10c441: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) <== NOT EXECUTED 10c448: 00 00 00 <== NOT EXECUTED the_thread->cpu_time_used.tv_nsec = 0; 10c44b: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) <== NOT EXECUTED 10c452: 00 00 00 <== NOT EXECUTED 10c455: 0f b7 53 08 movzwl 0x8(%ebx),%edx <== NOT EXECUTED 10c459: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c45c: 8b 41 1c mov 0x1c(%ecx),%eax <== NOT EXECUTED 10c45f: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10c462: 8b 45 30 mov 0x30(%ebp),%eax <== NOT EXECUTED 10c465: 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 ); 10c468: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10c46b: e8 40 0c 00 00 call 10d0b0 <_User_extensions_Thread_create> <== NOT EXECUTED if ( !extension_status ) { 10c470: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c473: 84 c0 test %al,%al <== NOT EXECUTED 10c475: 75 39 jne 10c4b0 <_Thread_Initialize+0x164> <== NOT EXECUTED if ( extensions_area ) 10c477: 85 f6 test %esi,%esi <== NOT EXECUTED 10c479: 74 0c je 10c487 <_Thread_Initialize+0x13b> <== NOT EXECUTED (void) _Workspace_Free( extensions_area ); 10c47b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c47e: 56 push %esi <== NOT EXECUTED 10c47f: e8 40 0f 00 00 call 10d3c4 <_Workspace_Free> <== NOT EXECUTED 10c484: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 10c487: 85 ff test %edi,%edi <== NOT EXECUTED 10c489: 74 0c je 10c497 <_Thread_Initialize+0x14b> <== NOT EXECUTED (void) _Workspace_Free( fp_area ); 10c48b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c48e: 57 push %edi <== NOT EXECUTED 10c48f: e8 30 0f 00 00 call 10d3c4 <_Workspace_Free> <== NOT EXECUTED 10c494: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 10c497: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c49a: 53 push %ebx <== NOT EXECUTED 10c49b: e8 6c 08 00 00 call 10cd0c <_Thread_Stack_Free> <== NOT EXECUTED 10c4a0: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c4a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return FALSE; } return TRUE; } 10c4a5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c4a8: 5b pop %ebx <== NOT EXECUTED 10c4a9: 5e pop %esi <== NOT EXECUTED 10c4aa: 5f pop %edi <== NOT EXECUTED 10c4ab: c9 leave <== NOT EXECUTED 10c4ac: c3 ret <== NOT EXECUTED 10c4ad: 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 ) { 10c4b0: b0 01 mov $0x1,%al <== NOT EXECUTED return FALSE; } return TRUE; } 10c4b2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c4b5: 5b pop %ebx <== NOT EXECUTED 10c4b6: 5e pop %esi <== NOT EXECUTED 10c4b7: 5f pop %edi <== NOT EXECUTED 10c4b8: c9 leave <== NOT EXECUTED 10c4b9: c3 ret <== NOT EXECUTED 10c4ba: 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 ); 10c4bc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c4bf: 6a 6c push $0x6c <== NOT EXECUTED 10c4c1: e8 16 0f 00 00 call 10d3dc <_Workspace_Allocate> <== NOT EXECUTED 10c4c6: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( !fp_area ) { 10c4c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c4cb: 85 c0 test %eax,%eax <== NOT EXECUTED 10c4cd: 0f 85 c0 fe ff ff jne 10c393 <_Thread_Initialize+0x47> <== NOT EXECUTED 10c4d3: eb c2 jmp 10c497 <_Thread_Initialize+0x14b> <== NOT EXECUTED 10c4d5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( 10c4d8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c4db: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax <== NOT EXECUTED 10c4e2: 50 push %eax <== NOT EXECUTED 10c4e3: e8 f4 0e 00 00 call 10d3dc <_Workspace_Allocate> <== NOT EXECUTED 10c4e8: 89 c6 mov %eax,%esi <== NOT EXECUTED (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 10c4ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c4ed: 85 c0 test %eax,%eax <== NOT EXECUTED 10c4ef: 74 96 je 10c487 <_Thread_Initialize+0x13b> <== NOT EXECUTED return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 10c4f1: 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++ ) 10c4f7: 83 3d 9c ea 11 00 ff cmpl $0xffffffff,0x11ea9c <== NOT EXECUTED 10c4fe: 0f 84 da fe ff ff je 10c3de <_Thread_Initialize+0x92> <== NOT EXECUTED 10c504: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c506: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10c508: a1 9c ea 11 00 mov 0x11ea9c,%eax <== NOT EXECUTED 10c50d: 40 inc %eax <== NOT EXECUTED 10c50e: 66 90 xchg %ax,%ax <== NOT EXECUTED the_thread->extensions[i] = NULL; 10c510: 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++ ) 10c517: 42 inc %edx <== NOT EXECUTED 10c518: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10c51a: 77 f4 ja 10c510 <_Thread_Initialize+0x1c4> <== NOT EXECUTED 10c51c: e9 bd fe ff ff jmp 10c3de <_Thread_Initialize+0x92> <== NOT EXECUTED */ if ( !stack_area ) { actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10c521: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c524: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10c527: 53 push %ebx <== NOT EXECUTED 10c528: e8 7b 07 00 00 call 10cca8 <_Thread_Stack_Allocate> <== NOT EXECUTED if ( !actual_stack_size || actual_stack_size < stack_size ) 10c52d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c530: 85 c0 test %eax,%eax <== NOT EXECUTED 10c532: 74 17 je 10c54b <_Thread_Initialize+0x1ff> <== NOT EXECUTED 10c534: 39 45 14 cmp %eax,0x14(%ebp) <== NOT EXECUTED 10c537: 77 12 ja 10c54b <_Thread_Initialize+0x1ff> <== NOT EXECUTED return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 10c539: 8b 93 d0 00 00 00 mov 0xd0(%ebx),%edx <== NOT EXECUTED the_thread->Start.core_allocated_stack = TRUE; 10c53f: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx) <== NOT EXECUTED 10c546: e9 2e fe ff ff jmp 10c379 <_Thread_Initialize+0x2d> <== NOT EXECUTED (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); return FALSE; 10c54b: 31 c0 xor %eax,%eax 10c54d: e9 53 ff ff ff jmp 10c4a5 <_Thread_Initialize+0x159> <== NOT EXECUTED 0010f49c <_Thread_Load_environment>: */ void _Thread_Load_environment( Thread_Control *the_thread ) { 10f49c: 55 push %ebp <== NOT EXECUTED 10f49d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f49f: 57 push %edi <== NOT EXECUTED 10f4a0: 56 push %esi <== NOT EXECUTED 10f4a1: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10f4a4: 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 ) { 10f4a7: 8b ba cc 00 00 00 mov 0xcc(%edx),%edi <== NOT EXECUTED 10f4ad: 85 ff test %edi,%edi <== NOT EXECUTED 10f4af: 74 12 je 10f4c3 <_Thread_Load_environment+0x27> <== NOT EXECUTED the_thread->fp_context = the_thread->Start.fp_context; 10f4b1: 89 ba ec 00 00 00 mov %edi,0xec(%edx) <== NOT EXECUTED _Context_Initialize_fp( &the_thread->fp_context ); 10f4b7: be e0 eb 11 00 mov $0x11ebe0,%esi <== NOT EXECUTED 10f4bc: b9 1b 00 00 00 mov $0x1b,%ecx <== NOT EXECUTED 10f4c1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED } else #endif is_fp = false; the_thread->do_post_task_switch_extension = false; 10f4c3: c6 42 75 00 movb $0x0,0x75(%edx) <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 10f4c7: 8a 82 ac 00 00 00 mov 0xac(%edx),%al <== NOT EXECUTED 10f4cd: 88 42 76 mov %al,0x76(%edx) <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 10f4d0: 8b 82 b0 00 00 00 mov 0xb0(%edx),%eax <== NOT EXECUTED 10f4d6: 89 42 7c mov %eax,0x7c(%edx) <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 10f4d9: 8b 82 b4 00 00 00 mov 0xb4(%edx),%eax <== NOT EXECUTED 10f4df: 89 82 80 00 00 00 mov %eax,0x80(%edx) <== NOT EXECUTED _Context_Initialize( 10f4e5: 83 ba b8 00 00 00 01 cmpl $0x1,0xb8(%edx) <== NOT EXECUTED 10f4ec: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10f4ee: 25 00 02 00 00 and $0x200,%eax <== NOT EXECUTED 10f4f3: 05 02 30 00 00 add $0x3002,%eax <== NOT EXECUTED 10f4f8: 89 82 d4 00 00 00 mov %eax,0xd4(%edx) <== NOT EXECUTED 10f4fe: 8b 82 c4 00 00 00 mov 0xc4(%edx),%eax <== NOT EXECUTED 10f504: 83 e8 04 sub $0x4,%eax <== NOT EXECUTED 10f507: 03 82 c8 00 00 00 add 0xc8(%edx),%eax <== NOT EXECUTED 10f50d: c7 00 ac ff 10 00 movl $0x10ffac,(%eax) <== NOT EXECUTED 10f513: 89 82 dc 00 00 00 mov %eax,0xdc(%edx) <== NOT EXECUTED 10f519: 89 82 d8 00 00 00 mov %eax,0xd8(%edx) <== NOT EXECUTED the_thread->Start.isr_level, _Thread_Handler, is_fp ); } 10f51f: 58 pop %eax <== NOT EXECUTED 10f520: 5e pop %esi <== NOT EXECUTED 10f521: 5f pop %edi <== NOT EXECUTED 10f522: c9 leave <== NOT EXECUTED 10f523: c3 ret <== NOT EXECUTED 0010f720 <_Thread_Ready>: */ void _Thread_Ready( Thread_Control *the_thread ) { 10f720: 55 push %ebp <== NOT EXECUTED 10f721: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f723: 53 push %ebx <== NOT EXECUTED 10f724: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Thread_Control *heir; _ISR_Disable( level ); 10f727: 9c pushf <== NOT EXECUTED 10f728: fa cli <== NOT EXECUTED 10f729: 5b pop %ebx <== NOT EXECUTED the_thread->current_state = STATES_READY; 10f72a: 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 10f731: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10f737: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10f73e: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10f741: 66 a1 b0 ea 11 00 mov 0x11eab0,%ax <== NOT EXECUTED 10f747: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10f74d: 66 a3 b0 ea 11 00 mov %ax,0x11eab0 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node ); 10f753: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10f759: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10f75c: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10f75e: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10f761: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10f764: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10f766: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10f769: 53 push %ebx <== NOT EXECUTED 10f76a: 9d popf <== NOT EXECUTED 10f76b: fa cli <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10f76c: 66 8b 0d b0 ea 11 00 mov 0x11eab0,%cx <== NOT EXECUTED 10f773: 31 d2 xor %edx,%edx <== NOT EXECUTED 10f775: 89 d0 mov %edx,%eax <== NOT EXECUTED 10f777: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10f77b: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10f77e: 66 8b 8c 00 40 eb 11 mov 0x11eb40(%eax,%eax,1),%cx <== NOT EXECUTED 10f785: 00 <== NOT EXECUTED 10f786: 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. 10f78a: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10f78d: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10f790: 01 d0 add %edx,%eax <== NOT EXECUTED 10f792: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10f795: 8b 15 c0 e9 11 00 mov 0x11e9c0,%edx <== NOT EXECUTED 10f79b: 8b 04 82 mov (%edx,%eax,4),%eax <== NOT EXECUTED 10f79e: a3 88 ea 11 00 mov %eax,0x11ea88 <== NOT EXECUTED static inline uint32_t _Protected_heap_Initialize( Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) 10f7a3: 8b 15 bc ea 11 00 mov 0x11eabc,%edx <== NOT EXECUTED _Thread_Calculate_heir(); heir = _Thread_Heir; if ( !_Thread_Is_executing( heir ) && _Thread_Executing->is_preemptible ) 10f7a9: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10f7ab: 74 0d je 10f7ba <_Thread_Ready+0x9a> <== NOT EXECUTED 10f7ad: 80 7a 76 00 cmpb $0x0,0x76(%edx) <== NOT EXECUTED 10f7b1: 74 07 je 10f7ba <_Thread_Ready+0x9a> <== NOT EXECUTED _Context_Switch_necessary = TRUE; 10f7b3: c6 05 cc ea 11 00 01 movb $0x1,0x11eacc <== NOT EXECUTED _ISR_Enable( level ); 10f7ba: 53 push %ebx <== NOT EXECUTED 10f7bb: 9d popf <== NOT EXECUTED } 10f7bc: 5b pop %ebx <== NOT EXECUTED 10f7bd: c9 leave <== NOT EXECUTED 10f7be: c3 ret <== NOT EXECUTED 00110368 <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 110368: 55 push %ebp <== NOT EXECUTED 110369: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11036b: 53 push %ebx <== NOT EXECUTED 11036c: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 11036f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED the_thread->resource_count = 0; 110372: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED the_thread->suspend_count = 0; 110379: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED the_thread->is_preemptible = the_thread->Start.is_preemptible; 110380: 8a 83 ac 00 00 00 mov 0xac(%ebx),%al <== NOT EXECUTED 110386: 88 43 76 mov %al,0x76(%ebx) <== NOT EXECUTED the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 110389: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 11038f: 89 43 7c mov %eax,0x7c(%ebx) <== NOT EXECUTED the_thread->budget_callout = the_thread->Start.budget_callout; 110392: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax <== NOT EXECUTED 110398: 89 83 80 00 00 00 mov %eax,0x80(%ebx) <== NOT EXECUTED the_thread->Start.pointer_argument = pointer_argument; 11039e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1103a1: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) <== NOT EXECUTED the_thread->Start.numeric_argument = numeric_argument; 1103a7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1103aa: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) <== NOT EXECUTED if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 1103b0: 53 push %ebx <== NOT EXECUTED 1103b1: e8 06 d0 ff ff call 10d3bc <_Thread_queue_Extract_with_proxy> <== NOT EXECUTED 1103b6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1103b9: 84 c0 test %al,%al <== NOT EXECUTED 1103bb: 75 06 jne 1103c3 <_Thread_Reset+0x5b> <== NOT EXECUTED if ( _Watchdog_Is_active( &the_thread->Timer ) ) 1103bd: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 1103c1: 74 25 je 1103e8 <_Thread_Reset+0x80> <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 1103c3: 8b 83 bc 00 00 00 mov 0xbc(%ebx),%eax <== NOT EXECUTED 1103c9: 39 43 14 cmp %eax,0x14(%ebx) <== NOT EXECUTED 1103cc: 74 12 je 1103e0 <_Thread_Reset+0x78> <== NOT EXECUTED the_thread->real_priority = the_thread->Start.initial_priority; 1103ce: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 1103d1: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1103d4: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 1103d7: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1103da: 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 ); 1103db: e9 dc d1 ff ff jmp 10d5bc <_Thread_Set_priority> <== NOT EXECUTED } } 1103e0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1103e3: c9 leave <== NOT EXECUTED 1103e4: c3 ret <== NOT EXECUTED 1103e5: 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 ); 1103e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1103eb: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 1103ee: 50 push %eax <== NOT EXECUTED 1103ef: e8 00 da ff ff call 10ddf4 <_Watchdog_Remove> <== NOT EXECUTED 1103f4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1103f7: eb ca jmp 1103c3 <_Thread_Reset+0x5b> <== NOT EXECUTED 0010f7c0 <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 10f7c0: 55 push %ebp <== NOT EXECUTED 10f7c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f7c3: 56 push %esi <== NOT EXECUTED 10f7c4: 53 push %ebx <== NOT EXECUTED ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10f7c5: 8b 0d bc ea 11 00 mov 0x11eabc,%ecx <== NOT EXECUTED ready = executing->ready; 10f7cb: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx <== NOT EXECUTED _ISR_Disable( level ); 10f7d1: 9c pushf <== NOT EXECUTED 10f7d2: fa cli <== NOT EXECUTED 10f7d3: 5e pop %esi <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10f7d4: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10f7d6: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10f7d9: 74 35 je 10f810 <_Thread_Reset_timeslice+0x50> <== NOT EXECUTED 10f7db: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10f7dd: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10f7e0: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10f7e3: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10f7e5: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10f7e8: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10f7ea: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10f7ed: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED 10f7f0: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10f7f2: 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 ); 10f7f5: 56 push %esi <== NOT EXECUTED 10f7f6: 9d popf <== NOT EXECUTED 10f7f7: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( executing ) ) 10f7f8: 3b 0d 88 ea 11 00 cmp 0x11ea88,%ecx <== NOT EXECUTED 10f7fe: 74 18 je 10f818 <_Thread_Reset_timeslice+0x58> <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; 10f800: c6 05 cc ea 11 00 01 movb $0x1,0x11eacc <== NOT EXECUTED _ISR_Enable( level ); 10f807: 56 push %esi <== NOT EXECUTED 10f808: 9d popf <== NOT EXECUTED } 10f809: 5b pop %ebx <== NOT EXECUTED 10f80a: 5e pop %esi <== NOT EXECUTED 10f80b: c9 leave <== NOT EXECUTED 10f80c: c3 ret <== NOT EXECUTED 10f80d: 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 ); 10f810: 56 push %esi <== NOT EXECUTED 10f811: 9d popf <== NOT EXECUTED _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10f812: 5b pop %ebx <== NOT EXECUTED 10f813: 5e pop %esi <== NOT EXECUTED 10f814: c9 leave <== NOT EXECUTED 10f815: c3 ret <== NOT EXECUTED 10f816: 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; 10f818: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10f81a: a3 88 ea 11 00 mov %eax,0x11ea88 <== NOT EXECUTED 10f81f: eb df jmp 10f800 <_Thread_Reset_timeslice+0x40> <== NOT EXECUTED 0010d528 <_Thread_Restart>: bool _Thread_Restart( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10d528: 55 push %ebp <== NOT EXECUTED 10d529: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d52b: 53 push %ebx <== NOT EXECUTED 10d52c: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d52f: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( !_States_Is_dormant( the_thread->current_state ) ) { 10d532: f6 43 10 01 testb $0x1,0x10(%ebx) <== NOT EXECUTED 10d536: 74 08 je 10d540 <_Thread_Restart+0x18> <== NOT EXECUTED 10d538: 31 c0 xor %eax,%eax <== NOT EXECUTED return TRUE; } return FALSE; } 10d53a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d53d: c9 leave <== NOT EXECUTED 10d53e: c3 ret <== NOT EXECUTED 10d53f: 90 nop <== NOT EXECUTED Thread_Entry_numeric_type numeric_argument ) { if ( !_States_Is_dormant( the_thread->current_state ) ) { _Thread_Set_transient( the_thread ); 10d540: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d543: 53 push %ebx <== NOT EXECUTED 10d544: e8 b7 01 00 00 call 10d700 <_Thread_Set_transient> <== NOT EXECUTED _Thread_Reset( the_thread, pointer_argument, numeric_argument ); 10d549: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10d54c: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10d54f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d552: 53 push %ebx <== NOT EXECUTED 10d553: e8 10 2e 00 00 call 110368 <_Thread_Reset> <== NOT EXECUTED _Thread_Load_environment( the_thread ); 10d558: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10d55b: e8 e4 2a 00 00 call 110044 <_Thread_Load_environment> <== NOT EXECUTED _Thread_Ready( the_thread ); 10d560: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10d563: e8 60 2d 00 00 call 1102c8 <_Thread_Ready> <== NOT EXECUTED _User_extensions_Thread_restart( the_thread ); 10d568: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10d56b: e8 94 06 00 00 call 10dc04 <_User_extensions_Thread_restart> <== NOT EXECUTED if ( _Thread_Is_executing ( the_thread ) ) 10d570: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d573: 3b 1d 7c 17 12 00 cmp 0x12177c,%ebx <== NOT EXECUTED 10d579: 74 09 je 10d584 <_Thread_Restart+0x5c> <== NOT EXECUTED 10d57b: b0 01 mov $0x1,%al <== NOT EXECUTED return TRUE; } return FALSE; } 10d57d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d580: c9 leave <== NOT EXECUTED 10d581: c3 ret <== NOT EXECUTED 10d582: 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 10d584: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax <== NOT EXECUTED 10d58a: 85 c0 test %eax,%eax <== NOT EXECUTED 10d58c: 74 12 je 10d5a0 <_Thread_Restart+0x78> <== NOT EXECUTED * @return NULL if unsuccessful and a pointer to the block if successful 10d58e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d591: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax <== NOT EXECUTED 10d597: 50 push %eax <== NOT EXECUTED 10d598: e8 31 0a 00 00 call 10dfce <_CPU_Context_restore_fp> <== NOT EXECUTED 10d59d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, 10d5a0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d5a3: a1 7c 17 12 00 mov 0x12177c,%eax <== NOT EXECUTED 10d5a8: 05 d4 00 00 00 add $0xd4,%eax <== NOT EXECUTED 10d5ad: 50 push %eax <== NOT EXECUTED 10d5ae: e8 0a 0a 00 00 call 10dfbd <_CPU_Context_restore> <== NOT EXECUTED 10d5b3: b0 01 mov $0x1,%al <== NOT EXECUTED 10d5b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d5b8: eb 80 jmp 10d53a <_Thread_Restart+0x12> <== NOT EXECUTED 0010dfe8 <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 10dfe8: 55 push %ebp <== NOT EXECUTED 10dfe9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dfeb: 53 push %ebx <== NOT EXECUTED 10dfec: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10dfef: 8a 45 0c mov 0xc(%ebp),%al <== NOT EXECUTED ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10dff2: 9c pushf <== NOT EXECUTED 10dff3: fa cli <== NOT EXECUTED 10dff4: 5b pop %ebx <== NOT EXECUTED if ( force == TRUE ) 10dff5: 84 c0 test %al,%al <== NOT EXECUTED 10dff7: 74 13 je 10e00c <_Thread_Resume+0x24> <== NOT EXECUTED the_thread->suspend_count = 0; 10dff9: 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; 10e000: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED if ( current_state & STATES_SUSPENDED ) { 10e003: a8 02 test $0x2,%al <== NOT EXECUTED 10e005: 75 15 jne 10e01c <_Thread_Resume+0x34> <== NOT EXECUTED _Context_Switch_necessary = TRUE; } } } _ISR_Enable( level ); 10e007: 53 push %ebx <== NOT EXECUTED 10e008: 9d popf <== NOT EXECUTED } 10e009: 5b pop %ebx <== NOT EXECUTED 10e00a: c9 leave <== NOT EXECUTED 10e00b: c3 ret <== NOT EXECUTED _ISR_Disable( level ); if ( force == TRUE ) the_thread->suspend_count = 0; else the_thread->suspend_count--; 10e00c: 8b 41 70 mov 0x70(%ecx),%eax <== NOT EXECUTED 10e00f: 48 dec %eax <== NOT EXECUTED 10e010: 89 41 70 mov %eax,0x70(%ecx) <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 10e013: 85 c0 test %eax,%eax <== NOT EXECUTED 10e015: 74 e9 je 10e000 <_Thread_Resume+0x18> <== NOT EXECUTED _ISR_Enable( level ); 10e017: 53 push %ebx <== NOT EXECUTED 10e018: 9d popf <== NOT EXECUTED } } } _ISR_Enable( level ); } 10e019: 5b pop %ebx <== NOT EXECUTED 10e01a: c9 leave <== NOT EXECUTED 10e01b: 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( 10e01c: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED return; } current_state = the_thread->current_state; if ( current_state & STATES_SUSPENDED ) { current_state = 10e01f: 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 ) ) { 10e022: 85 c0 test %eax,%eax <== NOT EXECUTED 10e024: 75 e1 jne 10e007 <_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 10e026: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx <== NOT EXECUTED 10e02c: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax <== NOT EXECUTED 10e033: 66 09 02 or %ax,(%edx) <== NOT EXECUTED * @return TRUE if successfully able to determine the size, FALSE otherwise 10e036: 66 a1 10 a6 12 00 mov 0x12a610,%ax <== NOT EXECUTED 10e03c: 0b 81 94 00 00 00 or 0x94(%ecx),%eax <== NOT EXECUTED 10e042: 66 a3 10 a6 12 00 mov %ax,0x12a610 <== NOT EXECUTED _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10e048: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax <== NOT EXECUTED 10e04e: 8d 50 04 lea 0x4(%eax),%edx <== NOT EXECUTED 10e051: 89 11 mov %edx,(%ecx) <== NOT EXECUTED 10e053: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10e056: 89 48 08 mov %ecx,0x8(%eax) <== NOT EXECUTED 10e059: 89 0a mov %ecx,(%edx) <== NOT EXECUTED 10e05b: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED _ISR_Flash( level ); 10e05e: 53 push %ebx <== NOT EXECUTED 10e05f: 9d popf <== NOT EXECUTED 10e060: fa cli <== NOT EXECUTED if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10e061: 8b 51 14 mov 0x14(%ecx),%edx <== NOT EXECUTED 10e064: a1 e8 a5 12 00 mov 0x12a5e8,%eax <== NOT EXECUTED 10e069: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 10e06c: 73 99 jae 10e007 <_Thread_Resume+0x1f> <== NOT EXECUTED _Thread_Heir = the_thread; 10e06e: 89 0d e8 a5 12 00 mov %ecx,0x12a5e8 <== NOT EXECUTED if ( _Thread_Executing->is_preemptible || 10e074: a1 1c a6 12 00 mov 0x12a61c,%eax <== NOT EXECUTED 10e079: 80 78 76 00 cmpb $0x0,0x76(%eax) <== NOT EXECUTED 10e07d: 74 0d je 10e08c <_Thread_Resume+0xa4> <== NOT EXECUTED the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10e07f: c6 05 2c a6 12 00 01 movb $0x1,0x12a62c <== NOT EXECUTED 10e086: e9 7c ff ff ff jmp 10e007 <_Thread_Resume+0x1f> <== NOT EXECUTED 10e08b: 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 || 10e08c: 85 d2 test %edx,%edx <== NOT EXECUTED 10e08e: 0f 85 73 ff ff ff jne 10e007 <_Thread_Resume+0x1f> <== NOT EXECUTED 10e094: eb e9 jmp 10e07f <_Thread_Resume+0x97> <== NOT EXECUTED 0010caf0 <_Thread_Set_priority>: void _Thread_Set_priority( Thread_Control *the_thread, Priority_Control new_priority ) { 10caf0: 55 push %ebp <== NOT EXECUTED 10caf1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10caf3: 56 push %esi <== NOT EXECUTED 10caf4: 53 push %ebx <== NOT EXECUTED 10caf5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10caf8: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED the_thread->current_priority = new_priority; 10cafb: 89 53 14 mov %edx,0x14(%ebx) <== NOT EXECUTED the_thread->ready = &_Thread_Ready_chain[ new_priority ]; 10cafe: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10cb01: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10cb04: 03 05 c0 e9 11 00 add 0x11e9c0,%eax <== NOT EXECUTED 10cb0a: 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. */ 10cb10: 89 d1 mov %edx,%ecx <== NOT EXECUTED 10cb12: c1 e9 04 shr $0x4,%ecx <== NOT EXECUTED bool _Protected_heap_Walk( Heap_Control *the_heap, int source, 10cb15: 0f b7 c9 movzwl %cx,%ecx <== NOT EXECUTED 10cb18: 8d 84 09 40 eb 11 00 lea 0x11eb40(%ecx,%ecx,1),%eax <== NOT EXECUTED 10cb1f: 89 83 90 00 00 00 mov %eax,0x90(%ebx) <== NOT EXECUTED bool do_dump ); 10cb25: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10cb2a: 89 c6 mov %eax,%esi <== NOT EXECUTED 10cb2c: d3 e6 shl %cl,%esi <== NOT EXECUTED 10cb2e: 89 f1 mov %esi,%ecx <== NOT EXECUTED /** 10cb30: 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 10cb37: f7 d1 not %ecx <== NOT EXECUTED 10cb39: 66 89 8b 98 00 00 00 mov %cx,0x98(%ebx) <== NOT EXECUTED * sizes. * 10cb40: 83 e2 0f and $0xf,%edx <== NOT EXECUTED 10cb43: 88 d1 mov %dl,%cl <== NOT EXECUTED 10cb45: d3 e0 shl %cl,%eax <== NOT EXECUTED * @param[in] the_heap pointer to heap header 10cb47: 66 89 83 96 00 00 00 mov %ax,0x96(%ebx) <== NOT EXECUTED * @param[in] the_info pointer to a status information area 10cb4e: f7 d0 not %eax <== NOT EXECUTED 10cb50: 66 89 83 9a 00 00 00 mov %ax,0x9a(%ebx) <== NOT EXECUTED _Priority_Initialize_information( &the_thread->Priority_map, new_priority ); } 10cb57: 5b pop %ebx <== NOT EXECUTED 10cb58: 5e pop %esi <== NOT EXECUTED 10cb59: c9 leave <== NOT EXECUTED 10cb5a: c3 ret <== NOT EXECUTED 0010cb5c <_Thread_Set_state>: void _Thread_Set_state( Thread_Control *the_thread, States_Control state ) { 10cb5c: 55 push %ebp <== NOT EXECUTED 10cb5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cb5f: 56 push %esi <== NOT EXECUTED 10cb60: 53 push %ebx <== NOT EXECUTED 10cb61: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10cb64: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Chain_Control *ready; ready = the_thread->ready; 10cb67: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx <== NOT EXECUTED _ISR_Disable( level ); 10cb6d: 9c pushf <== NOT EXECUTED 10cb6e: fa cli <== NOT EXECUTED 10cb6f: 5e pop %esi <== NOT EXECUTED if ( !_States_Is_ready( the_thread->current_state ) ) { 10cb70: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10cb73: 85 c0 test %eax,%eax <== NOT EXECUTED 10cb75: 75 2d jne 10cba4 <_Thread_Set_state+0x48> <== NOT EXECUTED _States_Set( state, the_thread->current_state ); _ISR_Enable( level ); return; } the_thread->current_state = state; 10cb77: 89 4b 10 mov %ecx,0x10(%ebx) <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10cb7a: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10cb7c: 3b 42 08 cmp 0x8(%edx),%eax <== NOT EXECUTED 10cb7f: 74 2f je 10cbb0 <_Thread_Set_state+0x54> <== NOT EXECUTED 10cb81: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10cb83: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10cb86: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10cb89: 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 ); 10cb8b: 56 push %esi <== NOT EXECUTED 10cb8c: 9d popf <== NOT EXECUTED 10cb8d: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) 10cb8e: 3b 1d 88 ea 11 00 cmp 0x11ea88,%ebx <== NOT EXECUTED 10cb94: 74 62 je 10cbf8 <_Thread_Set_state+0x9c> <== NOT EXECUTED _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) 10cb96: 3b 1d bc ea 11 00 cmp 0x11eabc,%ebx <== NOT EXECUTED 10cb9c: 74 4e je 10cbec <_Thread_Set_state+0x90> <== NOT EXECUTED _Context_Switch_necessary = TRUE; _ISR_Enable( level ); 10cb9e: 56 push %esi <== NOT EXECUTED 10cb9f: 9d popf <== NOT EXECUTED } 10cba0: 5b pop %ebx <== NOT EXECUTED 10cba1: 5e pop %esi <== NOT EXECUTED 10cba2: c9 leave <== NOT EXECUTED 10cba3: 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 = 10cba4: 09 c1 or %eax,%ecx <== NOT EXECUTED 10cba6: 89 4b 10 mov %ecx,0x10(%ebx) <== NOT EXECUTED _States_Set( state, the_thread->current_state ); _ISR_Enable( level ); 10cba9: 56 push %esi <== NOT EXECUTED 10cbaa: 9d popf <== NOT EXECUTED if ( _Thread_Is_executing( the_thread ) ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10cbab: 5b pop %ebx <== NOT EXECUTED 10cbac: 5e pop %esi <== NOT EXECUTED 10cbad: c9 leave <== NOT EXECUTED 10cbae: c3 ret <== NOT EXECUTED 10cbaf: 90 nop <== NOT EXECUTED 10cbb0: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10cbb3: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10cbb5: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10cbbc: 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 10cbbf: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10cbc5: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10cbcc: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10cbcf: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10cbd3: 75 b6 jne 10cb8b <_Thread_Set_state+0x2f> <== NOT EXECUTED * to be resized 10cbd5: 66 a1 b0 ea 11 00 mov 0x11eab0,%ax <== NOT EXECUTED 10cbdb: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10cbe1: 66 a3 b0 ea 11 00 mov %ax,0x11eab0 <== NOT EXECUTED 10cbe7: eb a2 jmp 10cb8b <_Thread_Set_state+0x2f> <== NOT EXECUTED 10cbe9: 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; 10cbec: c6 05 cc ea 11 00 01 movb $0x1,0x11eacc <== NOT EXECUTED 10cbf3: eb a9 jmp 10cb9e <_Thread_Set_state+0x42> <== NOT EXECUTED 10cbf5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10cbf8: 66 8b 0d b0 ea 11 00 mov 0x11eab0,%cx <== NOT EXECUTED 10cbff: 31 d2 xor %edx,%edx <== NOT EXECUTED 10cc01: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cc03: 66 0f bc c1 bsf %cx,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10cc07: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10cc0a: 66 8b 8c 00 40 eb 11 mov 0x11eb40(%eax,%eax,1),%cx <== NOT EXECUTED 10cc11: 00 <== NOT EXECUTED 10cc12: 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. 10cc16: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10cc19: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10cc1c: 01 d0 add %edx,%eax <== NOT EXECUTED 10cc1e: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10cc21: 8b 15 c0 e9 11 00 mov 0x11e9c0,%edx <== NOT EXECUTED 10cc27: 8b 04 82 mov (%edx,%eax,4),%eax <== NOT EXECUTED 10cc2a: a3 88 ea 11 00 mov %eax,0x11ea88 <== NOT EXECUTED 10cc2f: e9 62 ff ff ff jmp 10cb96 <_Thread_Set_state+0x3a> <== NOT EXECUTED 0010cc34 <_Thread_Set_transient>: */ void _Thread_Set_transient( Thread_Control *the_thread ) { 10cc34: 55 push %ebp <== NOT EXECUTED 10cc35: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cc37: 56 push %esi <== NOT EXECUTED 10cc38: 53 push %ebx <== NOT EXECUTED 10cc39: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED ISR_Level level; uint32_t old_state; Chain_Control *ready; ready = the_thread->ready; 10cc3c: 8b 8b 8c 00 00 00 mov 0x8c(%ebx),%ecx <== NOT EXECUTED _ISR_Disable( level ); 10cc42: 9c pushf <== NOT EXECUTED 10cc43: fa cli <== NOT EXECUTED 10cc44: 5e pop %esi <== NOT EXECUTED old_state = the_thread->current_state; 10cc45: 8b 53 10 mov 0x10(%ebx),%edx <== NOT EXECUTED the_thread->current_state = _States_Set( STATES_TRANSIENT, old_state ); 10cc48: 89 d0 mov %edx,%eax <== NOT EXECUTED 10cc4a: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 10cc4d: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED if ( _States_Is_ready( old_state ) ) { 10cc50: 85 d2 test %edx,%edx <== NOT EXECUTED 10cc52: 75 11 jne 10cc65 <_Thread_Set_transient+0x31> <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10cc54: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10cc56: 3b 41 08 cmp 0x8(%ecx),%eax <== NOT EXECUTED 10cc59: 74 11 je 10cc6c <_Thread_Set_transient+0x38> <== NOT EXECUTED 10cc5b: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 10cc5d: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10cc60: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10cc63: 89 10 mov %edx,(%eax) <== NOT EXECUTED } else _Chain_Extract_unprotected( &the_thread->Object.Node ); } _ISR_Enable( level ); 10cc65: 56 push %esi <== NOT EXECUTED 10cc66: 9d popf <== NOT EXECUTED } 10cc67: 5b pop %ebx <== NOT EXECUTED 10cc68: 5e pop %esi <== NOT EXECUTED 10cc69: c9 leave <== NOT EXECUTED 10cc6a: c3 ret <== NOT EXECUTED 10cc6b: 90 nop <== NOT EXECUTED 10cc6c: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10cc6f: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10cc71: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10cc78: 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 10cc7b: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax <== NOT EXECUTED 10cc81: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx <== NOT EXECUTED 10cc88: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10cc8b: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10cc8f: 75 d4 jne 10cc65 <_Thread_Set_transient+0x31> <== NOT EXECUTED * to be resized 10cc91: 66 a1 b0 ea 11 00 mov 0x11eab0,%ax <== NOT EXECUTED 10cc97: 23 83 98 00 00 00 and 0x98(%ebx),%eax <== NOT EXECUTED 10cc9d: 66 a3 b0 ea 11 00 mov %ax,0x11eab0 <== NOT EXECUTED 10cca3: eb c0 jmp 10cc65 <_Thread_Set_transient+0x31> <== NOT EXECUTED 0010cca8 <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 10cca8: 55 push %ebp <== NOT EXECUTED 10cca9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ccab: 53 push %ebx <== NOT EXECUTED 10ccac: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10ccaf: a1 b0 a4 11 00 mov 0x11a4b0,%eax <== NOT EXECUTED 10ccb4: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10ccb7: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10ccb9: 73 02 jae 10ccbd <_Thread_Stack_Allocate+0x15> <== NOT EXECUTED 10ccbb: 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 ) { 10ccbd: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10ccc2: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED 10ccc5: 85 c0 test %eax,%eax <== NOT EXECUTED 10ccc7: 74 33 je 10ccfc <_Thread_Stack_Allocate+0x54> <== NOT EXECUTED stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size ); 10ccc9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cccc: 53 push %ebx <== NOT EXECUTED 10cccd: ff d0 call *%eax <== NOT EXECUTED 10cccf: 89 c2 mov %eax,%edx <== NOT EXECUTED 10ccd1: 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 ) 10ccd4: 85 d2 test %edx,%edx <== NOT EXECUTED 10ccd6: 74 10 je 10cce8 <_Thread_Stack_Allocate+0x40> <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; 10ccd8: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ccdb: 89 90 d0 00 00 00 mov %edx,0xd0(%eax) <== NOT EXECUTED return the_stack_size; } 10cce1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10cce3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cce6: c9 leave <== NOT EXECUTED 10cce7: c3 ret <== NOT EXECUTED the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 10cce8: 31 db xor %ebx,%ebx <== NOT EXECUTED the_stack_size = 0; the_thread->Start.stack = stack_addr; 10ccea: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cced: 89 90 d0 00 00 00 mov %edx,0xd0(%eax) <== NOT EXECUTED return the_stack_size; } 10ccf3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10ccf5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ccf8: c9 leave <== NOT EXECUTED 10ccf9: c3 ret <== NOT EXECUTED 10ccfa: 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 ); 10ccfc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ccff: 53 push %ebx <== NOT EXECUTED 10cd00: e8 d7 06 00 00 call 10d3dc <_Workspace_Allocate> <== NOT EXECUTED 10cd05: 89 c2 mov %eax,%edx <== NOT EXECUTED 10cd07: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cd0a: eb c8 jmp 10ccd4 <_Thread_Stack_Allocate+0x2c> <== NOT EXECUTED 0010cd0c <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 10cd0c: 55 push %ebp <== NOT EXECUTED 10cd0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cd0f: 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 ) 10cd12: 80 ba c0 00 00 00 00 cmpb $0x0,0xc0(%edx) <== NOT EXECUTED 10cd19: 74 19 je 10cd34 <_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 ) 10cd1b: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10cd20: 8b 48 24 mov 0x24(%eax),%ecx <== NOT EXECUTED 10cd23: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10cd25: 74 11 je 10cd38 <_Thread_Stack_Free+0x2c> <== NOT EXECUTED (*_Configuration_Table->stack_free_hook)( 10cd27: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax <== NOT EXECUTED 10cd2d: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10cd30: 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)( 10cd31: ff e1 jmp *%ecx <== NOT EXECUTED 10cd33: 90 nop <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10cd34: c9 leave <== NOT EXECUTED 10cd35: c3 ret <== NOT EXECUTED 10cd36: 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 ); 10cd38: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax <== NOT EXECUTED 10cd3e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10cd41: 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 ); 10cd42: e9 7d 06 00 00 jmp 10d3c4 <_Workspace_Free> <== NOT EXECUTED 0010cda4 <_Thread_Start>: Thread_Start_types the_prototype, void *entry_point, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10cda4: 55 push %ebp <== NOT EXECUTED 10cda5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cda7: 53 push %ebx <== NOT EXECUTED 10cda8: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10cdab: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED if ( _States_Is_dormant( the_thread->current_state ) ) { 10cdae: f6 43 10 01 testb $0x1,0x10(%ebx) <== NOT EXECUTED 10cdb2: 75 08 jne 10cdbc <_Thread_Start+0x18> <== NOT EXECUTED 10cdb4: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; } return false; } 10cdb6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10cdb9: c9 leave <== NOT EXECUTED 10cdba: c3 ret <== NOT EXECUTED 10cdbb: 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; 10cdbc: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10cdbf: 89 83 9c 00 00 00 mov %eax,0x9c(%ebx) <== NOT EXECUTED the_thread->Start.prototype = the_prototype; 10cdc5: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10cdc8: 89 83 a0 00 00 00 mov %eax,0xa0(%ebx) <== NOT EXECUTED the_thread->Start.pointer_argument = pointer_argument; 10cdce: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10cdd1: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) <== NOT EXECUTED the_thread->Start.numeric_argument = numeric_argument; 10cdd7: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 10cdda: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) <== NOT EXECUTED _Thread_Load_environment( the_thread ); 10cde0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cde3: 53 push %ebx <== NOT EXECUTED 10cde4: e8 b3 26 00 00 call 10f49c <_Thread_Load_environment> <== NOT EXECUTED _Thread_Ready( the_thread ); 10cde9: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10cdec: e8 2f 29 00 00 call 10f720 <_Thread_Ready> <== NOT EXECUTED _User_extensions_Thread_start( the_thread ); 10cdf1: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10cdf4: e8 3f 03 00 00 call 10d138 <_User_extensions_Thread_start> <== NOT EXECUTED 10cdf9: b0 01 mov $0x1,%al <== NOT EXECUTED 10cdfb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return true; } return false; } 10cdfe: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ce01: c9 leave <== NOT EXECUTED 10ce02: c3 ret <== NOT EXECUTED 0010cd48 <_Thread_Start_multitasking>: * ready chain * select heir */ void _Thread_Start_multitasking( void ) { 10cd48: 55 push %ebp <== NOT EXECUTED 10cd49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cd4b: 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( 10cd4e: c7 05 c4 eb 11 00 03 movl $0x3,0x11ebc4 <== NOT EXECUTED 10cd55: 00 00 00 <== NOT EXECUTED * the system is shut down. */ _System_state_Set( SYSTEM_STATE_UP ); _Context_Switch_necessary = FALSE; 10cd58: c6 05 cc ea 11 00 00 movb $0x0,0x11eacc <== NOT EXECUTED _Thread_Executing = _Thread_Heir; 10cd5f: a1 88 ea 11 00 mov 0x11ea88,%eax <== NOT EXECUTED 10cd64: a3 bc ea 11 00 mov %eax,0x11eabc <== 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 ) 10cd69: 8b 90 ec 00 00 00 mov 0xec(%eax),%edx <== NOT EXECUTED 10cd6f: 85 d2 test %edx,%edx <== NOT EXECUTED 10cd71: 74 16 je 10cd89 <_Thread_Start_multitasking+0x41> <== NOT EXECUTED _Context_Restore_fp( &_Thread_Heir->fp_context ); 10cd73: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cd76: 05 ec 00 00 00 add $0xec,%eax <== NOT EXECUTED 10cd7b: 50 push %eax <== NOT EXECUTED 10cd7c: e8 3d 07 00 00 call 10d4be <_CPU_Context_restore_fp> <== NOT EXECUTED 10cd81: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cd84: a1 88 ea 11 00 mov 0x11ea88,%eax <== NOT EXECUTED #endif _Context_Switch( &_Thread_BSP_context, &_Thread_Heir->Registers ); 10cd89: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cd8c: 05 d4 00 00 00 add $0xd4,%eax <== NOT EXECUTED 10cd91: 50 push %eax <== NOT EXECUTED 10cd92: 68 e0 e9 11 00 push $0x11e9e0 <== NOT EXECUTED 10cd97: e8 e4 06 00 00 call 10d480 <_CPU_Context_switch> <== NOT EXECUTED 10cd9c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10cd9f: c9 leave <== NOT EXECUTED 10cda0: c3 ret <== NOT EXECUTED 0010e3ac <_Thread_Suspend>: */ void _Thread_Suspend( Thread_Control *the_thread ) { 10e3ac: 55 push %ebp <== NOT EXECUTED 10e3ad: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e3af: 56 push %esi <== NOT EXECUTED 10e3b0: 53 push %ebx <== NOT EXECUTED 10e3b1: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Chain_Control *ready; ready = the_thread->ready; 10e3b4: 8b 91 8c 00 00 00 mov 0x8c(%ecx),%edx <== NOT EXECUTED _ISR_Disable( level ); 10e3ba: 9c pushf <== NOT EXECUTED 10e3bb: fa cli <== NOT EXECUTED 10e3bc: 5b pop %ebx <== NOT EXECUTED the_thread->suspend_count++; 10e3bd: ff 41 70 incl 0x70(%ecx) <== NOT EXECUTED if ( !_States_Is_ready( the_thread->current_state ) ) { 10e3c0: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED 10e3c3: 85 c0 test %eax,%eax <== NOT EXECUTED 10e3c5: 75 31 jne 10e3f8 <_Thread_Suspend+0x4c> <== NOT EXECUTED _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); return; } the_thread->current_state = STATES_SUSPENDED; 10e3c7: c7 41 10 02 00 00 00 movl $0x2,0x10(%ecx) <== NOT EXECUTED if ( _Chain_Has_only_one_node( ready ) ) { 10e3ce: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10e3d0: 3b 42 08 cmp 0x8(%edx),%eax <== NOT EXECUTED 10e3d3: 74 2f je 10e404 <_Thread_Suspend+0x58> <== NOT EXECUTED 10e3d5: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10e3d7: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10e3da: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10e3dd: 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 ); 10e3df: 53 push %ebx <== NOT EXECUTED 10e3e0: 9d popf <== NOT EXECUTED 10e3e1: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( the_thread ) ) 10e3e2: 3b 0d e8 a5 12 00 cmp 0x12a5e8,%ecx <== NOT EXECUTED 10e3e8: 74 62 je 10e44c <_Thread_Suspend+0xa0> <== NOT EXECUTED _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) 10e3ea: 3b 0d 1c a6 12 00 cmp 0x12a61c,%ecx <== NOT EXECUTED 10e3f0: 74 4e je 10e440 <_Thread_Suspend+0x94> <== NOT EXECUTED _Context_Switch_necessary = TRUE; _ISR_Enable( level ); 10e3f2: 53 push %ebx <== NOT EXECUTED 10e3f3: 9d popf <== NOT EXECUTED } 10e3f4: 5b pop %ebx <== NOT EXECUTED 10e3f5: 5e pop %esi <== NOT EXECUTED 10e3f6: c9 leave <== NOT EXECUTED 10e3f7: 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 = 10e3f8: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 10e3fb: 89 41 10 mov %eax,0x10(%ecx) <== NOT EXECUTED _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); 10e3fe: 53 push %ebx <== NOT EXECUTED 10e3ff: 9d popf <== NOT EXECUTED if ( _Thread_Is_executing( the_thread ) ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10e400: 5b pop %ebx <== NOT EXECUTED 10e401: 5e pop %esi <== NOT EXECUTED 10e402: c9 leave <== NOT EXECUTED 10e403: c3 ret <== NOT EXECUTED 10e404: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10e407: 89 02 mov %eax,(%edx) <== NOT EXECUTED 10e409: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10e410: 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 10e413: 8b 81 90 00 00 00 mov 0x90(%ecx),%eax <== NOT EXECUTED 10e419: 66 8b 91 9a 00 00 00 mov 0x9a(%ecx),%dx <== NOT EXECUTED 10e420: 66 21 10 and %dx,(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the user block 10e423: 66 83 38 00 cmpw $0x0,(%eax) <== NOT EXECUTED 10e427: 75 b6 jne 10e3df <_Thread_Suspend+0x33> <== NOT EXECUTED * to be resized 10e429: 66 a1 10 a6 12 00 mov 0x12a610,%ax <== NOT EXECUTED 10e42f: 23 81 98 00 00 00 and 0x98(%ecx),%eax <== NOT EXECUTED 10e435: 66 a3 10 a6 12 00 mov %ax,0x12a610 <== NOT EXECUTED 10e43b: eb a2 jmp 10e3df <_Thread_Suspend+0x33> <== NOT EXECUTED 10e43d: 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; 10e440: c6 05 2c a6 12 00 01 movb $0x1,0x12a62c <== NOT EXECUTED 10e447: eb a9 jmp 10e3f2 <_Thread_Suspend+0x46> <== NOT EXECUTED 10e449: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10e44c: 66 8b 35 10 a6 12 00 mov 0x12a610,%si <== NOT EXECUTED 10e453: 31 d2 xor %edx,%edx <== NOT EXECUTED 10e455: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e457: 66 0f bc c6 bsf %si,%ax <== NOT EXECUTED * at @a starting_address to @a the_heap. Any coalescing which is 10e45b: 0f b7 c0 movzwl %ax,%eax <== NOT EXECUTED 10e45e: 66 8b b4 00 a0 a6 12 mov 0x12a6a0(%eax,%eax,1),%si <== NOT EXECUTED 10e465: 00 <== NOT EXECUTED 10e466: 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. 10e46a: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10e46d: 0f b7 d2 movzwl %dx,%edx <== NOT EXECUTED 10e470: 01 d0 add %edx,%eax <== NOT EXECUTED 10e472: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10e475: 8b 15 20 a5 12 00 mov 0x12a520,%edx <== NOT EXECUTED 10e47b: 8b 04 82 mov (%edx,%eax,4),%eax <== NOT EXECUTED 10e47e: a3 e8 a5 12 00 mov %eax,0x12a5e8 <== NOT EXECUTED 10e483: e9 62 ff ff ff jmp 10e3ea <_Thread_Suspend+0x3e> <== NOT EXECUTED 0010ce04 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10ce04: 55 push %ebp <== NOT EXECUTED 10ce05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ce07: 53 push %ebx <== NOT EXECUTED 10ce08: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED Thread_Control *executing; executing = _Thread_Executing; 10ce0b: 8b 1d bc ea 11 00 mov 0x11eabc,%ebx <== NOT EXECUTED /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10ce11: 80 7b 76 00 cmpb $0x0,0x76(%ebx) <== NOT EXECUTED 10ce15: 74 19 je 10ce30 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED return; if ( !_States_Is_ready( executing->current_state ) ) 10ce17: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 10ce1a: 85 c0 test %eax,%eax <== NOT EXECUTED 10ce1c: 75 12 jne 10ce30 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10ce1e: 8b 43 7c mov 0x7c(%ebx),%eax <== NOT EXECUTED 10ce21: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10ce24: 72 0a jb 10ce30 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED 10ce26: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10ce29: 76 29 jbe 10ce54 <_Thread_Tickle_timeslice+0x50> <== NOT EXECUTED 10ce2b: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10ce2e: 74 08 je 10ce38 <_Thread_Tickle_timeslice+0x34> <== NOT EXECUTED case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) (*executing->budget_callout)( executing ); break; } } 10ce30: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ce33: c9 leave <== NOT EXECUTED 10ce34: c3 ret <== NOT EXECUTED 10ce35: 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 ) 10ce38: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 10ce3b: 48 dec %eax <== NOT EXECUTED 10ce3c: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10ce3f: 85 c0 test %eax,%eax <== NOT EXECUTED 10ce41: 75 ed jne 10ce30 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED (*executing->budget_callout)( executing ); 10ce43: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ce46: 53 push %ebx <== NOT EXECUTED 10ce47: ff 93 80 00 00 00 call *0x80(%ebx) <== NOT EXECUTED 10ce4d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ce50: eb de jmp 10ce30 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED 10ce52: 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 ) { 10ce54: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 10ce57: 48 dec %eax <== NOT EXECUTED 10ce58: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10ce5b: 85 c0 test %eax,%eax <== NOT EXECUTED 10ce5d: 7f d1 jg 10ce30 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED _Thread_Reset_timeslice(); 10ce5f: e8 5c 29 00 00 call 10f7c0 <_Thread_Reset_timeslice> <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10ce64: a1 c4 e9 11 00 mov 0x11e9c4,%eax <== NOT EXECUTED 10ce69: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10ce6c: eb c2 jmp 10ce30 <_Thread_Tickle_timeslice+0x2c> <== NOT EXECUTED 0010ce70 <_Thread_Yield_processor>: * ready chain * select heir */ void _Thread_Yield_processor( void ) { 10ce70: 55 push %ebp <== NOT EXECUTED 10ce71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ce73: 56 push %esi <== NOT EXECUTED 10ce74: 53 push %ebx <== NOT EXECUTED ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10ce75: 8b 0d bc ea 11 00 mov 0x11eabc,%ecx <== NOT EXECUTED ready = executing->ready; 10ce7b: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx <== NOT EXECUTED _ISR_Disable( level ); 10ce81: 9c pushf <== NOT EXECUTED 10ce82: fa cli <== NOT EXECUTED 10ce83: 5e pop %esi <== NOT EXECUTED if ( !_Chain_Has_only_one_node( ready ) ) { 10ce84: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10ce86: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10ce89: 74 35 je 10cec0 <_Thread_Yield_processor+0x50> <== NOT EXECUTED 10ce8b: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10ce8d: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10ce90: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10ce93: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10ce95: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 10ce98: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10ce9a: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10ce9d: 89 4b 08 mov %ecx,0x8(%ebx) <== NOT EXECUTED 10cea0: 89 08 mov %ecx,(%eax) <== NOT EXECUTED 10cea2: 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 ); 10cea5: 56 push %esi <== NOT EXECUTED 10cea6: 9d popf <== NOT EXECUTED 10cea7: fa cli <== NOT EXECUTED if ( _Thread_Is_heir( executing ) ) 10cea8: 3b 0d 88 ea 11 00 cmp 0x11ea88,%ecx <== NOT EXECUTED 10ceae: 74 1c je 10cecc <_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; 10ceb0: c6 05 cc ea 11 00 01 movb $0x1,0x11eacc <== NOT EXECUTED _ISR_Enable( level ); 10ceb7: 56 push %esi <== NOT EXECUTED 10ceb8: 9d popf <== NOT EXECUTED } 10ceb9: 5b pop %ebx <== NOT EXECUTED 10ceba: 5e pop %esi <== NOT EXECUTED 10cebb: c9 leave <== NOT EXECUTED 10cebc: c3 ret <== NOT EXECUTED 10cebd: 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 ) ) 10cec0: 3b 0d 88 ea 11 00 cmp 0x11ea88,%ecx <== NOT EXECUTED 10cec6: 75 e8 jne 10ceb0 <_Thread_Yield_processor+0x40> <== NOT EXECUTED 10cec8: eb ed jmp 10ceb7 <_Thread_Yield_processor+0x47> <== NOT EXECUTED 10ceca: 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; 10cecc: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10cece: a3 88 ea 11 00 mov %eax,0x11ea88 <== NOT EXECUTED 10ced3: eb db jmp 10ceb0 <_Thread_Yield_processor+0x40> <== NOT EXECUTED 0010bd80 <_Thread_blocking_operation_Cancel>: void _Thread_blocking_operation_Cancel( Thread_blocking_operation_States sync_state, Thread_Control *the_thread, ISR_Level level ) { 10bd80: 55 push %ebp <== NOT EXECUTED 10bd81: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10bd83: 53 push %ebx <== NOT EXECUTED 10bd84: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10bd87: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10bd8a: 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; 10bd8d: 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 ) ) { 10bd94: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10bd98: 74 16 je 10bdb0 <_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 ); 10bd9a: 50 push %eax <== NOT EXECUTED 10bd9b: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10bd9c: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10bda3: 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 } 10bda6: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10bda9: c9 leave <== NOT EXECUTED 10bdaa: e9 51 01 00 00 jmp 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 10bdaf: 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 */ 10bdb0: 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 ); 10bdb7: 50 push %eax <== NOT EXECUTED 10bdb8: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10bdb9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bdbc: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10bdbf: 50 push %eax <== NOT EXECUTED 10bdc0: e8 23 15 00 00 call 10d2e8 <_Watchdog_Remove> <== NOT EXECUTED 10bdc5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10bdc8: eb d2 jmp 10bd9c <_Thread_blocking_operation_Cancel+0x1c> <== NOT EXECUTED 0010c62c <_Thread_queue_Dequeue>: */ Thread_Control *_Thread_queue_Dequeue( Thread_queue_Control *the_thread_queue ) { 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 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 ) 10c636: 83 7b 34 01 cmpl $0x1,0x34(%ebx) <== NOT EXECUTED 10c63a: 74 20 je 10c65c <_Thread_queue_Dequeue+0x30> <== NOT EXECUTED 10c63c: b8 24 f5 10 00 mov $0x10f524,%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 ); 10c641: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c644: 53 push %ebx <== NOT EXECUTED 10c645: ff d0 call *%eax <== NOT EXECUTED 10c647: 89 c2 mov %eax,%edx <== NOT EXECUTED _ISR_Disable( level ); 10c649: 9c pushf <== NOT EXECUTED 10c64a: fa cli <== NOT EXECUTED 10c64b: 59 pop %ecx <== NOT EXECUTED if ( !the_thread ) { 10c64c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c64f: 85 c0 test %eax,%eax <== NOT EXECUTED 10c651: 74 11 je 10c664 <_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 ); 10c653: 51 push %ecx <== NOT EXECUTED 10c654: 9d popf <== NOT EXECUTED return the_thread; } 10c655: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c657: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10c65a: c9 leave <== NOT EXECUTED 10c65b: 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 ) 10c65c: b8 7c c6 10 00 mov $0x10c67c,%eax <== NOT EXECUTED 10c661: eb de jmp 10c641 <_Thread_queue_Dequeue+0x15> <== NOT EXECUTED 10c663: 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) || 10c664: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10c667: 48 dec %eax <== NOT EXECUTED 10c668: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10c66b: 77 e6 ja 10c653 <_Thread_queue_Dequeue+0x27> <== NOT EXECUTED (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 10c66d: c7 43 30 03 00 00 00 movl $0x3,0x30(%ebx) <== NOT EXECUTED the_thread = _Thread_Executing; 10c674: 8b 15 bc ea 11 00 mov 0x11eabc,%edx <== NOT EXECUTED 10c67a: eb d7 jmp 10c653 <_Thread_queue_Dequeue+0x27> <== NOT EXECUTED 0010f524 <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 10f524: 55 push %ebp <== NOT EXECUTED 10f525: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f527: 56 push %esi <== NOT EXECUTED 10f528: 53 push %ebx <== NOT EXECUTED 10f529: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 10f52c: 9c pushf <== NOT EXECUTED 10f52d: fa cli <== NOT EXECUTED 10f52e: 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( 10f52f: 8b 11 mov (%ecx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 10f531: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10f534: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10f536: 74 62 je 10f59a <_Thread_queue_Dequeue_fifo+0x76> <== NOT EXECUTED 10f538: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10f53a: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10f53c: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread = (Thread_Control *) 10f53f: 89 d3 mov %edx,%ebx <== NOT EXECUTED _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo ); the_thread->Wait.queue = NULL; 10f541: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10f548: 83 7a 50 02 cmpl $0x2,0x50(%edx) <== NOT EXECUTED 10f54c: 74 1e je 10f56c <_Thread_queue_Dequeue_fifo+0x48> <== NOT EXECUTED _ISR_Enable( level ); 10f54e: 56 push %esi <== NOT EXECUTED 10f54f: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10f550: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f553: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10f558: 52 push %edx <== NOT EXECUTED 10f559: e8 a2 c9 ff ff call 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 10f55e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return the_thread; } _ISR_Enable( level ); return NULL; } 10f561: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10f563: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f566: 5b pop %ebx <== NOT EXECUTED 10f567: 5e pop %esi <== NOT EXECUTED 10f568: c9 leave <== NOT EXECUTED 10f569: c3 ret <== NOT EXECUTED 10f56a: 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 */ 10f56c: 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 ); 10f573: 56 push %esi <== NOT EXECUTED 10f574: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10f575: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f578: 8d 42 48 lea 0x48(%edx),%eax <== NOT EXECUTED 10f57b: 50 push %eax <== NOT EXECUTED 10f57c: e8 67 dd ff ff call 10d2e8 <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10f581: 58 pop %eax <== NOT EXECUTED 10f582: 5a pop %edx <== NOT EXECUTED 10f583: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10f588: 53 push %ebx <== NOT EXECUTED 10f589: e8 72 c9 ff ff call 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 10f58e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return the_thread; } _ISR_Enable( level ); return NULL; } 10f591: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10f593: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10f596: 5b pop %ebx <== NOT EXECUTED 10f597: 5e pop %esi <== NOT EXECUTED 10f598: c9 leave <== NOT EXECUTED 10f599: c3 ret <== NOT EXECUTED #endif return the_thread; } _ISR_Enable( level ); 10f59a: 56 push %esi <== NOT EXECUTED 10f59b: 9d popf <== NOT EXECUTED 10f59c: 31 db xor %ebx,%ebx <== NOT EXECUTED 10f59e: eb c1 jmp 10f561 <_Thread_queue_Dequeue_fifo+0x3d> <== NOT EXECUTED 0010c67c <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 10c67c: 55 push %ebp <== NOT EXECUTED 10c67d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c67f: 57 push %edi <== NOT EXECUTED 10c680: 56 push %esi <== NOT EXECUTED 10c681: 53 push %ebx <== NOT EXECUTED 10c682: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c685: 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 ); 10c688: 9c pushf <== NOT EXECUTED 10c689: fa cli <== NOT EXECUTED 10c68a: 5f pop %edi <== NOT EXECUTED 10c68b: 31 d2 xor %edx,%edx <== NOT EXECUTED 10c68d: 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( 10c68f: 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 ] ) ) { 10c692: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10c695: 8d 44 86 04 lea 0x4(%esi,%eax,4),%eax <== NOT EXECUTED 10c699: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10c69b: 75 1f jne 10c6bc <_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++ ) { 10c69d: 42 inc %edx <== NOT EXECUTED 10c69e: 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 ; 10c6a1: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 10c6a4: 75 e9 jne 10c68f <_Thread_queue_Dequeue_priority+0x13> <== NOT EXECUTED } /* * We did not find a thread to unblock. */ _ISR_Enable( level ); 10c6a6: 57 push %edi <== NOT EXECUTED 10c6a7: 9d popf <== NOT EXECUTED 10c6a8: 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 ); } 10c6af: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10c6b2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c6b5: 5b pop %ebx <== NOT EXECUTED 10c6b6: 5e pop %esi <== NOT EXECUTED 10c6b7: 5f pop %edi <== NOT EXECUTED 10c6b8: c9 leave <== NOT EXECUTED 10c6b9: c3 ret <== NOT EXECUTED 10c6ba: 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 *) 10c6bc: 89 5d e8 mov %ebx,-0x18(%ebp) <== NOT EXECUTED */ _ISR_Enable( level ); return NULL; dequeue: the_thread->Wait.queue = NULL; 10c6bf: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED new_first_node = the_thread->Wait.Block2n.first; 10c6c6: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; 10c6c9: 8b 33 mov (%ebx),%esi <== NOT EXECUTED previous_node = the_thread->Object.Node.previous; 10c6cb: 8b 4b 04 mov 0x4(%ebx),%ecx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10c6ce: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10c6d1: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10c6d3: 0f 84 85 00 00 00 je 10c75e <_Thread_queue_Dequeue_priority+0xe2> <== NOT EXECUTED last_node = the_thread->Wait.Block2n.last; 10c6d9: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10c6dc: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED new_second_node = new_first_node->next; 10c6df: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10c6e1: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED previous_node->next = new_first_node; 10c6e4: 89 11 mov %edx,(%ecx) <== NOT EXECUTED next_node->previous = new_first_node; 10c6e6: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED new_first_node->next = next_node; 10c6e9: 89 32 mov %esi,(%edx) <== NOT EXECUTED new_first_node->previous = previous_node; 10c6eb: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10c6ee: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10c6f1: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10c6f4: 74 1a je 10c710 <_Thread_queue_Dequeue_priority+0x94> <== NOT EXECUTED /* > two threads on 2-n */ new_second_node->previous = 10c6f6: 8d 42 38 lea 0x38(%edx),%eax <== NOT EXECUTED 10c6f9: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 10c6fc: 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; 10c6ff: 89 4a 38 mov %ecx,0x38(%edx) <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 10c702: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10c705: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10c708: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10c70b: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10c70e: 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 ) ) { 10c710: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10c714: 74 1e je 10c734 <_Thread_queue_Dequeue_priority+0xb8> <== NOT EXECUTED _ISR_Enable( level ); 10c716: 57 push %edi <== NOT EXECUTED 10c717: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10c718: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c71b: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10c720: 53 push %ebx <== NOT EXECUTED 10c721: e8 da f7 ff ff call 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 10c726: 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 ); } 10c729: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10c72c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c72f: 5b pop %ebx <== NOT EXECUTED 10c730: 5e pop %esi <== NOT EXECUTED 10c731: 5f pop %edi <== NOT EXECUTED 10c732: c9 leave <== NOT EXECUTED 10c733: 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 */ 10c734: 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 ); 10c73b: 57 push %edi <== NOT EXECUTED 10c73c: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10c73d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c740: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10c743: 50 push %eax <== NOT EXECUTED 10c744: e8 9f 0b 00 00 call 10d2e8 <_Watchdog_Remove> <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10c749: 58 pop %eax <== NOT EXECUTED 10c74a: 5a pop %edx <== NOT EXECUTED 10c74b: 68 f8 ff 03 10 push $0x1003fff8 <== NOT EXECUTED 10c750: 53 push %ebx <== NOT EXECUTED 10c751: e8 aa f7 ff ff call 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 10c756: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c759: e9 51 ff ff ff jmp 10c6af <_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; 10c75e: 89 31 mov %esi,(%ecx) <== NOT EXECUTED next_node->previous = previous_node; 10c760: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED 10c763: eb ab jmp 10c710 <_Thread_queue_Dequeue_priority+0x94> <== NOT EXECUTED 0010f5a0 <_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 ) { 10f5a0: 55 push %ebp <== NOT EXECUTED 10f5a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f5a3: 56 push %esi <== NOT EXECUTED 10f5a4: 53 push %ebx <== NOT EXECUTED 10f5a5: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10f5a8: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Thread_blocking_operation_States sync_state; ISR_Level level; _ISR_Disable( level ); 10f5ab: 9c pushf <== NOT EXECUTED 10f5ac: fa cli <== NOT EXECUTED 10f5ad: 5e pop %esi <== NOT EXECUTED sync_state = the_thread_queue->sync_state; 10f5ae: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10f5b1: c7 42 30 00 00 00 00 movl $0x0,0x30(%edx) <== NOT EXECUTED if (sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) { 10f5b8: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED 10f5bb: 74 0b je 10f5c8 <_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; 10f5bd: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10f5c0: 89 30 mov %esi,(%eax) <== NOT EXECUTED return sync_state; } 10f5c2: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10f5c4: 5b pop %ebx <== NOT EXECUTED 10f5c5: 5e pop %esi <== NOT EXECUTED 10f5c6: c9 leave <== NOT EXECUTED 10f5c7: c3 ret <== NOT EXECUTED 10f5c8: 8d 42 04 lea 0x4(%edx),%eax <== NOT EXECUTED 10f5cb: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 10f5cd: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10f5d0: 89 5a 08 mov %ebx,0x8(%edx) <== NOT EXECUTED 10f5d3: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10f5d5: 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; 10f5d8: 89 53 44 mov %edx,0x44(%ebx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; _ISR_Enable( level ); 10f5db: 56 push %esi <== NOT EXECUTED 10f5dc: 9d popf <== NOT EXECUTED * * WARNING! Returning with interrupts disabled! */ *level_p = level; return sync_state; } 10f5dd: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10f5df: 5b pop %ebx <== NOT EXECUTED 10f5e0: 5e pop %esi <== NOT EXECUTED 10f5e1: c9 leave <== NOT EXECUTED 10f5e2: c3 ret <== NOT EXECUTED 0010c800 <_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 ) { 10c800: 55 push %ebp <== NOT EXECUTED 10c801: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c803: 57 push %edi <== NOT EXECUTED 10c804: 56 push %esi <== NOT EXECUTED 10c805: 53 push %ebx <== NOT EXECUTED 10c806: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c809: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10c80c: 83 c0 3c add $0x3c,%eax <== NOT EXECUTED 10c80f: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10c812: 89 42 38 mov %eax,0x38(%edx) <== NOT EXECUTED 10c815: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx) <== NOT EXECUTED 10c81c: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c81e: 83 c0 38 add $0x38,%eax <== NOT EXECUTED 10c821: 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; 10c824: 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. 10c827: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10c829: 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; 10c82c: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c82f: 8b 49 38 mov 0x38(%ecx),%ecx <== NOT EXECUTED 10c832: 89 4d f0 mov %ecx,-0x10(%ebp) <== NOT EXECUTED if ( _Thread_queue_Is_reverse_search( priority ) ) 10c835: f6 c3 20 test $0x20,%bl <== NOT EXECUTED 10c838: 75 66 jne 10c8a0 <_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 10c83a: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10c83d: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 10c840: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c843: 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; 10c847: 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 ); 10c84a: 9c pushf <== NOT EXECUTED 10c84b: fa cli <== NOT EXECUTED 10c84c: 5e pop %esi <== NOT EXECUTED search_thread = (Thread_Control *) header->first; 10c84d: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10c850: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c853: 8b 14 08 mov (%eax,%ecx,1),%edx <== NOT EXECUTED while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c856: 39 fa cmp %edi,%edx <== NOT EXECUTED 10c858: 75 1b jne 10c875 <_Thread_queue_Enqueue_priority+0x75> <== NOT EXECUTED 10c85a: e9 1a 01 00 00 jmp 10c979 <_Thread_queue_Enqueue_priority+0x179> <== NOT EXECUTED 10c85f: 90 nop <== NOT EXECUTED break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10c860: 56 push %esi <== NOT EXECUTED 10c861: 9d popf <== NOT EXECUTED 10c862: fa cli <== NOT EXECUTED if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c863: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10c866: 85 42 10 test %eax,0x10(%edx) <== NOT EXECUTED 10c869: 0f 84 ad 00 00 00 je 10c91c <_Thread_queue_Enqueue_priority+0x11c> <== NOT EXECUTED _ISR_Enable( level ); goto restart_forward_search; } search_thread = 10c86f: 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 ) ) { 10c871: 39 fa cmp %edi,%edx <== NOT EXECUTED 10c873: 74 07 je 10c87c <_Thread_queue_Enqueue_priority+0x7c> <== NOT EXECUTED search_priority = search_thread->current_priority; 10c875: 8b 4a 14 mov 0x14(%edx),%ecx <== NOT EXECUTED if ( priority <= search_priority ) 10c878: 39 cb cmp %ecx,%ebx <== NOT EXECUTED 10c87a: 77 e4 ja 10c860 <_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 ) ) { 10c87c: 89 d7 mov %edx,%edi <== NOT EXECUTED } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10c87e: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c881: 83 78 30 01 cmpl $0x1,0x30(%eax) <== NOT EXECUTED 10c885: 0f 84 99 00 00 00 je 10c924 <_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; 10c88b: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10c88e: 89 30 mov %esi,(%eax) <== NOT EXECUTED return the_thread_queue->sync_state; 10c890: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c893: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED } 10c896: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c899: 5b pop %ebx <== NOT EXECUTED 10c89a: 5e pop %esi <== NOT EXECUTED 10c89b: 5f pop %edi <== NOT EXECUTED 10c89c: c9 leave <== NOT EXECUTED 10c89d: c3 ret <== NOT EXECUTED 10c89e: 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; 10c8a0: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10c8a3: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c8a6: 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; 10c8a9: 8d 79 08 lea 0x8(%ecx),%edi <== NOT EXECUTED 10c8ac: 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; 10c8af: 0f b6 05 b4 a4 11 00 movzbl 0x11a4b4,%eax <== NOT EXECUTED 10c8b6: 40 inc %eax <== NOT EXECUTED _ISR_Disable( level ); 10c8b7: 9c pushf <== NOT EXECUTED 10c8b8: fa cli <== NOT EXECUTED 10c8b9: 5e pop %esi <== NOT EXECUTED search_thread = (Thread_Control *) header->last; 10c8ba: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 10c8bd: 8b 17 mov (%edi),%edx <== NOT EXECUTED while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c8bf: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 10c8c1: 75 17 jne 10c8da <_Thread_queue_Enqueue_priority+0xda> <== NOT EXECUTED 10c8c3: eb 1c jmp 10c8e1 <_Thread_queue_Enqueue_priority+0xe1> <== NOT EXECUTED 10c8c5: 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 ); 10c8c8: 56 push %esi <== NOT EXECUTED 10c8c9: 9d popf <== NOT EXECUTED 10c8ca: fa cli <== NOT EXECUTED if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c8cb: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 10c8ce: 85 7a 10 test %edi,0x10(%edx) <== NOT EXECUTED 10c8d1: 74 45 je 10c918 <_Thread_queue_Enqueue_priority+0x118> <== NOT EXECUTED _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) 10c8d3: 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 ) ) { 10c8d6: 39 ca cmp %ecx,%edx <== NOT EXECUTED 10c8d8: 74 07 je 10c8e1 <_Thread_queue_Enqueue_priority+0xe1> <== NOT EXECUTED search_priority = search_thread->current_priority; 10c8da: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED if ( priority >= search_priority ) 10c8dd: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10c8df: 72 e7 jb 10c8c8 <_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 ) ) { 10c8e1: 89 d7 mov %edx,%edi <== NOT EXECUTED } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10c8e3: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c8e6: 83 79 30 01 cmpl $0x1,0x30(%ecx) <== NOT EXECUTED 10c8ea: 75 9f jne 10c88b <_Thread_queue_Enqueue_priority+0x8b> <== NOT EXECUTED THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c8ec: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) <== NOT EXECUTED if ( priority == search_priority ) 10c8f3: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 10c8f5: 74 5d je 10c954 <_Thread_queue_Enqueue_priority+0x154> <== NOT EXECUTED goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10c8f7: 8b 02 mov (%edx),%eax <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10c8f9: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10c8fc: 89 07 mov %eax,(%edi) <== NOT EXECUTED the_node->previous = search_node; 10c8fe: 89 57 04 mov %edx,0x4(%edi) <== NOT EXECUTED search_node->next = the_node; 10c901: 89 3a mov %edi,(%edx) <== NOT EXECUTED next_node->previous = the_node; 10c903: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10c906: 89 4f 44 mov %ecx,0x44(%edi) <== NOT EXECUTED _ISR_Enable( level ); 10c909: 56 push %esi <== NOT EXECUTED 10c90a: 9d popf <== NOT EXECUTED 10c90b: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10c910: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c913: 5b pop %ebx <== NOT EXECUTED 10c914: 5e pop %esi <== NOT EXECUTED 10c915: 5f pop %edi <== NOT EXECUTED 10c916: c9 leave <== NOT EXECUTED 10c917: 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 ); 10c918: 56 push %esi <== NOT EXECUTED 10c919: 9d popf <== NOT EXECUTED 10c91a: eb 93 jmp 10c8af <_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 ); 10c91c: 56 push %esi <== NOT EXECUTED 10c91d: 9d popf <== NOT EXECUTED 10c91e: e9 27 ff ff ff jmp 10c84a <_Thread_queue_Enqueue_priority+0x4a> <== NOT EXECUTED 10c923: 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; 10c924: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED if ( priority == search_priority ) 10c92b: 39 cb cmp %ecx,%ebx <== NOT EXECUTED 10c92d: 74 25 je 10c954 <_Thread_queue_Enqueue_priority+0x154> <== NOT EXECUTED goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10c92f: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c932: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10c935: 89 11 mov %edx,(%ecx) <== NOT EXECUTED the_node->previous = previous_node; 10c937: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED previous_node->next = the_node; 10c93a: 89 08 mov %ecx,(%eax) <== NOT EXECUTED search_node->previous = the_node; 10c93c: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10c93f: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10c942: 89 79 44 mov %edi,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10c945: 56 push %esi <== NOT EXECUTED 10c946: 9d popf <== NOT EXECUTED 10c947: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10c94c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10c94f: 5b pop %ebx <== NOT EXECUTED 10c950: 5e pop %esi <== NOT EXECUTED 10c951: 5f pop %edi <== NOT EXECUTED 10c952: c9 leave <== NOT EXECUTED 10c953: c3 ret <== NOT EXECUTED 10c954: 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; 10c957: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c95a: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10c95d: 89 01 mov %eax,(%ecx) <== NOT EXECUTED the_node->previous = previous_node; 10c95f: 89 51 04 mov %edx,0x4(%ecx) <== NOT EXECUTED previous_node->next = the_node; 10c962: 89 0a mov %ecx,(%edx) <== NOT EXECUTED search_node->previous = the_node; 10c964: 89 48 04 mov %ecx,0x4(%eax) <== NOT EXECUTED the_thread->Wait.queue = the_thread_queue; 10c967: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10c96a: 89 79 44 mov %edi,0x44(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10c96d: 56 push %esi <== NOT EXECUTED 10c96e: 9d popf <== NOT EXECUTED 10c96f: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10c974: e9 1d ff ff ff jmp 10c896 <_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 ) ) { 10c979: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 10c97e: e9 fb fe ff ff jmp 10c87e <_Thread_queue_Enqueue_priority+0x7e> <== NOT EXECUTED 0010c768 <_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 ) { 10c768: 55 push %ebp <== NOT EXECUTED 10c769: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c76b: 57 push %edi <== NOT EXECUTED 10c76c: 56 push %esi <== NOT EXECUTED 10c76d: 53 push %ebx <== NOT EXECUTED 10c76e: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 10c771: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10c774: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Thread_queue_Control *, Thread_Control *, ISR_Level * ); the_thread = _Thread_Executing; 10c777: 8b 1d bc ea 11 00 mov 0x11eabc,%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 ); 10c77d: ff 76 38 pushl 0x38(%esi) <== NOT EXECUTED 10c780: 53 push %ebx <== NOT EXECUTED 10c781: e8 d6 03 00 00 call 10cb5c <_Thread_Set_state> <== NOT EXECUTED /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { 10c786: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c789: 85 ff test %edi,%edi <== NOT EXECUTED 10c78b: 75 33 jne 10c7c0 <_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 ) 10c78d: 83 7e 34 01 cmpl $0x1,0x34(%esi) <== NOT EXECUTED 10c791: 74 64 je 10c7f7 <_Thread_queue_Enqueue_with_handler+0x8f> <== NOT EXECUTED 10c793: ba a0 f5 10 00 mov $0x10f5a0,%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 ); 10c798: 51 push %ecx <== NOT EXECUTED 10c799: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10c79c: 50 push %eax <== NOT EXECUTED 10c79d: 53 push %ebx <== NOT EXECUTED 10c79e: 56 push %esi <== NOT EXECUTED 10c79f: ff d2 call *%edx <== NOT EXECUTED if ( sync_state != THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) 10c7a1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c7a4: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10c7a7: 74 0e je 10c7b7 <_Thread_queue_Enqueue_with_handler+0x4f> <== NOT EXECUTED _Thread_blocking_operation_Cancel( sync_state, the_thread, level ); 10c7a9: 52 push %edx <== NOT EXECUTED 10c7aa: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10c7ad: 53 push %ebx <== NOT EXECUTED 10c7ae: 50 push %eax <== NOT EXECUTED 10c7af: e8 cc f5 ff ff call 10bd80 <_Thread_blocking_operation_Cancel> <== NOT EXECUTED 10c7b4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10c7b7: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c7ba: 5b pop %ebx <== NOT EXECUTED 10c7bb: 5e pop %esi <== NOT EXECUTED 10c7bc: 5f pop %edi <== NOT EXECUTED 10c7bd: c9 leave <== NOT EXECUTED 10c7be: c3 ret <== NOT EXECUTED 10c7bf: 90 nop <== NOT EXECUTED /* * If the thread wants to timeout, then schedule its timer. */ if ( timeout ) { _Watchdog_Initialize( 10c7c0: 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. * 10c7c3: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10c7ca: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10c7cd: 89 53 64 mov %edx,0x64(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 10c7d0: 89 43 68 mov %eax,0x68(%ebx) <== NOT EXECUTED * the heap 10c7d3: 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, 10c7da: 89 7b 54 mov %edi,0x54(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 10c7dd: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c7e0: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10c7e3: 50 push %eax <== NOT EXECUTED 10c7e4: 68 dc ea 11 00 push $0x11eadc <== NOT EXECUTED 10c7e9: e8 ca 09 00 00 call 10d1b8 <_Watchdog_Insert> <== NOT EXECUTED 10c7ee: 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 ) 10c7f1: 83 7e 34 01 cmpl $0x1,0x34(%esi) <== NOT EXECUTED 10c7f5: 75 9c jne 10c793 <_Thread_queue_Enqueue_with_handler+0x2b> <== NOT EXECUTED 10c7f7: ba 00 c8 10 00 mov $0x10c800,%edx <== NOT EXECUTED 10c7fc: eb 9a jmp 10c798 <_Thread_queue_Enqueue_with_handler+0x30> <== NOT EXECUTED 0010f5e4 <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10f5e4: 55 push %ebp <== NOT EXECUTED 10f5e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f5e7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f5ea: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10f5ed: 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 ) 10f5f0: 83 78 34 01 cmpl $0x1,0x34(%eax) <== NOT EXECUTED 10f5f4: 74 0e je 10f604 <_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 ); 10f5f6: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 10f5f9: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10f5fc: 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 ); 10f5fd: e9 ce 0a 00 00 jmp 1100d0 <_Thread_queue_Extract_fifo> <== NOT EXECUTED 10f602: 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 ); 10f604: 51 push %ecx <== NOT EXECUTED 10f605: 6a 00 push $0x0 <== NOT EXECUTED 10f607: 52 push %edx <== NOT EXECUTED 10f608: 50 push %eax <== NOT EXECUTED 10f609: e8 06 00 00 00 call 10f614 <_Thread_queue_Extract_priority_helper> <== NOT EXECUTED 10f60e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); } 10f611: c9 leave <== NOT EXECUTED 10f612: c3 ret <== NOT EXECUTED 001100d0 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 1100d0: 55 push %ebp <== NOT EXECUTED 1100d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1100d3: 53 push %ebx <== NOT EXECUTED 1100d4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 1100d7: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 1100da: 9c pushf <== NOT EXECUTED 1100db: fa cli <== NOT EXECUTED 1100dc: 59 pop %ecx <== NOT EXECUTED if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 1100dd: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) <== NOT EXECUTED 1100e4: 74 2e je 110114 <_Thread_queue_Extract_fifo+0x44> <== NOT EXECUTED 1100e6: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 1100e8: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 1100eb: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 1100ee: 89 10 mov %edx,(%eax) <== NOT EXECUTED return; } _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; 1100f0: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) <== NOT EXECUTED if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 1100f7: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 1100fb: 74 1f je 11011c <_Thread_queue_Extract_fifo+0x4c> <== NOT EXECUTED _ISR_Enable( level ); 1100fd: 51 push %ecx <== NOT EXECUTED 1100fe: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 1100ff: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 110106: 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 } 110109: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 11010c: c9 leave <== NOT EXECUTED 11010d: e9 ee bd ff ff jmp 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 110112: 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 ); 110114: 51 push %ecx <== NOT EXECUTED 110115: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 110116: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110119: c9 leave <== NOT EXECUTED 11011a: c3 ret <== NOT EXECUTED 11011b: 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 */ 11011c: 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 ); 110123: 51 push %ecx <== NOT EXECUTED 110124: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 110125: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110128: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 11012b: 50 push %eax <== NOT EXECUTED 11012c: e8 b7 d1 ff ff call 10d2e8 <_Watchdog_Remove> <== NOT EXECUTED 110131: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110134: eb c9 jmp 1100ff <_Thread_queue_Extract_fifo+0x2f> <== NOT EXECUTED 0010f614 <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, bool requeuing ) { 10f614: 55 push %ebp <== NOT EXECUTED 10f615: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f617: 57 push %edi <== NOT EXECUTED 10f618: 56 push %esi <== NOT EXECUTED 10f619: 53 push %ebx <== NOT EXECUTED 10f61a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f61d: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10f620: 8a 45 10 mov 0x10(%ebp),%al <== NOT EXECUTED 10f623: 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 ); 10f626: 9c pushf <== NOT EXECUTED 10f627: fa cli <== NOT EXECUTED 10f628: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10f62b: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) <== NOT EXECUTED 10f632: 74 68 je 10f69c <_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; 10f634: 8b 33 mov (%ebx),%esi <== NOT EXECUTED previous_node = the_node->previous; 10f636: 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( 10f639: 8b 53 38 mov 0x38(%ebx),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10f63c: 8d 43 3c lea 0x3c(%ebx),%eax <== NOT EXECUTED 10f63f: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10f641: 74 71 je 10f6b4 <_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; 10f643: 8b 43 40 mov 0x40(%ebx),%eax <== NOT EXECUTED 10f646: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED new_second_node = new_first_node->next; 10f649: 8b 3a mov (%edx),%edi <== NOT EXECUTED previous_node->next = new_first_node; 10f64b: 89 11 mov %edx,(%ecx) <== NOT EXECUTED next_node->previous = new_first_node; 10f64d: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED new_first_node->next = next_node; 10f650: 89 32 mov %esi,(%edx) <== NOT EXECUTED new_first_node->previous = previous_node; 10f652: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10f655: 8b 43 38 mov 0x38(%ebx),%eax <== NOT EXECUTED 10f658: 3b 43 40 cmp 0x40(%ebx),%eax <== NOT EXECUTED 10f65b: 74 17 je 10f674 <_Thread_queue_Extract_priority_helper+0x60> <== NOT EXECUTED /* > two threads on 2-n */ new_second_node->previous = 10f65d: 8d 42 38 lea 0x38(%edx),%eax <== NOT EXECUTED 10f660: 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; 10f663: 89 7a 38 mov %edi,0x38(%edx) <== NOT EXECUTED new_first_thread->Wait.Block2n.last = last_node; 10f666: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10f669: 89 42 40 mov %eax,0x40(%edx) <== NOT EXECUTED last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10f66c: 8d 42 3c lea 0x3c(%edx),%eax <== NOT EXECUTED 10f66f: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10f672: 89 02 mov %eax,(%edx) <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 10f674: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) <== NOT EXECUTED 10f678: 75 2e jne 10f6a8 <_Thread_queue_Extract_priority_helper+0x94> <== NOT EXECUTED _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10f67a: 83 7b 50 02 cmpl $0x2,0x50(%ebx) <== NOT EXECUTED 10f67e: 74 3c je 10f6bc <_Thread_queue_Extract_priority_helper+0xa8> <== NOT EXECUTED _ISR_Enable( level ); 10f680: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10f683: 9d popf <== NOT EXECUTED void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10f684: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) <== NOT EXECUTED 10f68b: 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 } 10f68e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f691: 5b pop %ebx <== NOT EXECUTED 10f692: 5e pop %esi <== NOT EXECUTED 10f693: 5f pop %edi <== NOT EXECUTED 10f694: c9 leave <== NOT EXECUTED 10f695: e9 66 c8 ff ff jmp 10bf00 <_Thread_Clear_state> <== NOT EXECUTED 10f69a: 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 ); 10f69c: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10f69f: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10f6a0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f6a3: 5b pop %ebx <== NOT EXECUTED 10f6a4: 5e pop %esi <== NOT EXECUTED 10f6a5: 5f pop %edi <== NOT EXECUTED 10f6a6: c9 leave <== NOT EXECUTED 10f6a7: c3 ret <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { _ISR_Enable( level ); 10f6a8: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10f6ab: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10f6ac: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f6af: 5b pop %ebx <== NOT EXECUTED 10f6b0: 5e pop %esi <== NOT EXECUTED 10f6b1: 5f pop %edi <== NOT EXECUTED 10f6b2: c9 leave <== NOT EXECUTED 10f6b3: 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; 10f6b4: 89 31 mov %esi,(%ecx) <== NOT EXECUTED next_node->previous = previous_node; 10f6b6: 89 4e 04 mov %ecx,0x4(%esi) <== NOT EXECUTED 10f6b9: eb b9 jmp 10f674 <_Thread_queue_Extract_priority_helper+0x60> <== NOT EXECUTED 10f6bb: 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 */ 10f6bc: 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 ); 10f6c3: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10f6c6: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10f6c7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f6ca: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10f6cd: 50 push %eax <== NOT EXECUTED 10f6ce: e8 15 dc ff ff call 10d2e8 <_Watchdog_Remove> <== NOT EXECUTED 10f6d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f6d6: eb ac jmp 10f684 <_Thread_queue_Extract_priority_helper+0x70> <== NOT EXECUTED 0010c984 <_Thread_queue_Extract_with_proxy>: */ bool _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 10c984: 55 push %ebp <== NOT EXECUTED 10c985: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c987: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c98a: 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 ) ) { 10c98d: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax) <== NOT EXECUTED 10c994: 75 06 jne 10c99c <_Thread_queue_Extract_with_proxy+0x18> <== NOT EXECUTED 10c996: 31 c0 xor %eax,%eax <== NOT EXECUTED _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); return TRUE; } return FALSE; } 10c998: c9 leave <== NOT EXECUTED 10c999: c3 ret <== NOT EXECUTED 10c99a: 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 ); 10c99c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10c99f: 50 push %eax <== NOT EXECUTED 10c9a0: ff 70 44 pushl 0x44(%eax) <== NOT EXECUTED 10c9a3: e8 3c 2c 00 00 call 10f5e4 <_Thread_queue_Extract> <== NOT EXECUTED 10c9a8: b0 01 mov $0x1,%al <== NOT EXECUTED 10c9aa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return TRUE; } return FALSE; } 10c9ad: c9 leave <== NOT EXECUTED 10c9ae: c3 ret <== NOT EXECUTED 0011a9e0 <_Thread_queue_First>: */ Thread_Control *_Thread_queue_First( Thread_queue_Control *the_thread_queue ) { 11a9e0: 55 push %ebp <== NOT EXECUTED 11a9e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11a9e3: 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 ) 11a9e6: 83 78 34 01 cmpl $0x1,0x34(%eax) <== NOT EXECUTED 11a9ea: 74 0c je 11a9f8 <_Thread_queue_First+0x18> <== NOT EXECUTED 11a9ec: b9 f8 b3 11 00 mov $0x11b3f8,%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 ); 11a9f1: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 11a9f4: 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 ); 11a9f5: ff e1 jmp *%ecx <== NOT EXECUTED 11a9f7: 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 ) 11a9f8: b9 04 aa 11 00 mov $0x11aa04,%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 ); 11a9fd: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 11aa00: 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 ); 11aa01: ff e1 jmp *%ecx <== NOT EXECUTED 0011b3f8 <_Thread_queue_First_fifo>: */ Thread_Control *_Thread_queue_First_fifo( Thread_queue_Control *the_thread_queue ) { 11b3f8: 55 push %ebp <== NOT EXECUTED 11b3f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11b3fb: 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( 11b3fe: 8b 10 mov (%eax),%edx <== NOT EXECUTED if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) 11b400: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 11b403: 39 c2 cmp %eax,%edx <== NOT EXECUTED 11b405: 74 05 je 11b40c <_Thread_queue_First_fifo+0x14> <== NOT EXECUTED return (Thread_Control *) the_thread_queue->Queues.Fifo.first; 11b407: 89 d0 mov %edx,%eax <== NOT EXECUTED return NULL; } 11b409: c9 leave <== NOT EXECUTED 11b40a: c3 ret <== NOT EXECUTED 11b40b: 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 ) ) 11b40c: 31 c0 xor %eax,%eax <== NOT EXECUTED return (Thread_Control *) the_thread_queue->Queues.Fifo.first; return NULL; } 11b40e: c9 leave <== NOT EXECUTED 11b40f: c3 ret <== NOT EXECUTED 0011aa04 <_Thread_queue_First_priority>: */ Thread_Control *_Thread_queue_First_priority ( Thread_queue_Control *the_thread_queue ) { 11aa04: 55 push %ebp <== NOT EXECUTED 11aa05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11aa07: 56 push %esi <== NOT EXECUTED 11aa08: 53 push %ebx <== NOT EXECUTED 11aa09: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 11aa0c: 31 d2 xor %edx,%edx <== NOT EXECUTED 11aa0e: 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( 11aa10: 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 ] ) ) 11aa13: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 11aa16: 8d 44 86 04 lea 0x4(%esi,%eax,4),%eax <== NOT EXECUTED 11aa1a: 39 c3 cmp %eax,%ebx <== NOT EXECUTED 11aa1c: 75 12 jne 11aa30 <_Thread_queue_First_priority+0x2c> <== NOT EXECUTED { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 11aa1e: 42 inc %edx <== NOT EXECUTED 11aa1f: 83 c1 0c add $0xc,%ecx <== NOT EXECUTED ) { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 11aa22: 83 fa 04 cmp $0x4,%edx <== NOT EXECUTED 11aa25: 75 e9 jne 11aa10 <_Thread_queue_First_priority+0xc> <== NOT EXECUTED 11aa27: 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; } 11aa29: 5b pop %ebx <== NOT EXECUTED 11aa2a: 5e pop %esi <== NOT EXECUTED 11aa2b: c9 leave <== NOT EXECUTED 11aa2c: c3 ret <== NOT EXECUTED 11aa2d: 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 *) 11aa30: 89 d8 mov %ebx,%eax <== NOT EXECUTED the_thread_queue->Queues.Priority[ index ].first; } return NULL; } 11aa32: 5b pop %ebx <== NOT EXECUTED 11aa33: 5e pop %esi <== NOT EXECUTED 11aa34: c9 leave <== NOT EXECUTED 11aa35: c3 ret <== NOT EXECUTED 0010c9b0 <_Thread_queue_Flush>: void _Thread_queue_Flush( Thread_queue_Control *the_thread_queue, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 10c9b0: 55 push %ebp <== NOT EXECUTED 10c9b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c9b3: 56 push %esi <== NOT EXECUTED 10c9b4: 53 push %ebx <== NOT EXECUTED 10c9b5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10c9b8: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED 10c9bb: eb 06 jmp 10c9c3 <_Thread_queue_Flush+0x13> <== NOT EXECUTED 10c9bd: 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; 10c9c0: 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 )) ) { 10c9c3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c9c6: 56 push %esi <== NOT EXECUTED 10c9c7: e8 60 fc ff ff call 10c62c <_Thread_queue_Dequeue> <== NOT EXECUTED 10c9cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10c9cf: 85 c0 test %eax,%eax <== NOT EXECUTED 10c9d1: 75 ed jne 10c9c0 <_Thread_queue_Flush+0x10> <== NOT EXECUTED ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; } } 10c9d3: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10c9d6: 5b pop %ebx <== NOT EXECUTED 10c9d7: 5e pop %esi <== NOT EXECUTED 10c9d8: c9 leave <== NOT EXECUTED 10c9d9: c3 ret <== NOT EXECUTED 0010c9dc <_Thread_queue_Initialize>: Thread_queue_Control *the_thread_queue, Thread_queue_Disciplines the_discipline, States_Control state, uint32_t timeout_status ) { 10c9dc: 55 push %ebp <== NOT EXECUTED 10c9dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c9df: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10c9e2: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED the_thread_queue->state = state; 10c9e5: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10c9e8: 89 51 38 mov %edx,0x38(%ecx) <== NOT EXECUTED the_thread_queue->discipline = the_discipline; 10c9eb: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED the_thread_queue->timeout_status = timeout_status; 10c9ee: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 10c9f1: 89 51 3c mov %edx,0x3c(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c9f4: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) <== NOT EXECUTED if ( the_discipline == THREAD_QUEUE_DISCIPLINE_PRIORITY ) { 10c9fb: 48 dec %eax <== NOT EXECUTED 10c9fc: 74 12 je 10ca10 <_Thread_queue_Initialize+0x34> <== NOT EXECUTED 10c9fe: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10ca01: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10ca03: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10ca0a: 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 ); } } 10ca0d: c9 leave <== NOT EXECUTED 10ca0e: c3 ret <== NOT EXECUTED 10ca0f: 90 nop <== NOT EXECUTED 10ca10: 8d 41 04 lea 0x4(%ecx),%eax <== NOT EXECUTED 10ca13: 89 01 mov %eax,(%ecx) <== NOT EXECUTED 10ca15: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED 10ca1c: 89 49 08 mov %ecx,0x8(%ecx) <== NOT EXECUTED 10ca1f: 8d 41 10 lea 0x10(%ecx),%eax <== NOT EXECUTED 10ca22: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED 10ca25: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx) <== NOT EXECUTED 10ca2c: 8d 41 0c lea 0xc(%ecx),%eax <== NOT EXECUTED 10ca2f: 89 41 14 mov %eax,0x14(%ecx) <== NOT EXECUTED 10ca32: 8d 41 1c lea 0x1c(%ecx),%eax <== NOT EXECUTED 10ca35: 89 41 18 mov %eax,0x18(%ecx) <== NOT EXECUTED 10ca38: c7 41 1c 00 00 00 00 movl $0x0,0x1c(%ecx) <== NOT EXECUTED 10ca3f: 8d 41 18 lea 0x18(%ecx),%eax <== NOT EXECUTED 10ca42: 89 41 20 mov %eax,0x20(%ecx) <== NOT EXECUTED 10ca45: 8d 41 28 lea 0x28(%ecx),%eax <== NOT EXECUTED 10ca48: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED 10ca4b: c7 41 28 00 00 00 00 movl $0x0,0x28(%ecx) <== NOT EXECUTED 10ca52: 8d 41 24 lea 0x24(%ecx),%eax <== NOT EXECUTED 10ca55: 89 41 2c mov %eax,0x2c(%ecx) <== NOT EXECUTED 10ca58: c9 leave <== NOT EXECUTED 10ca59: c3 ret <== NOT EXECUTED 0010f6d8 <_Thread_queue_Process_timeout>: #include void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { 10f6d8: 55 push %ebp <== NOT EXECUTED 10f6d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f6db: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f6de: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 10f6e1: 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 && 10f6e4: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 10f6e7: 85 c0 test %eax,%eax <== NOT EXECUTED 10f6e9: 74 08 je 10f6f3 <_Thread_queue_Process_timeout+0x1b> <== NOT EXECUTED 10f6eb: 3b 0d bc ea 11 00 cmp 0x11eabc,%ecx <== NOT EXECUTED 10f6f1: 74 19 je 10f70c <_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; 10f6f3: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 10f6f6: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10f6f9: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f6fc: 51 push %ecx <== NOT EXECUTED 10f6fd: ff 71 44 pushl 0x44(%ecx) <== NOT EXECUTED 10f700: e8 df fe ff ff call 10f5e4 <_Thread_queue_Extract> <== NOT EXECUTED 10f705: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 10f708: c9 leave <== NOT EXECUTED 10f709: c3 ret <== NOT EXECUTED 10f70a: 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 ) { 10f70c: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10f70f: 74 f7 je 10f708 <_Thread_queue_Process_timeout+0x30> <== NOT EXECUTED the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10f711: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 10f714: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10f717: 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 ); } } 10f71e: c9 leave <== NOT EXECUTED 10f71f: c3 ret <== NOT EXECUTED 0010ca5c <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10ca5c: 55 push %ebp <== NOT EXECUTED 10ca5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ca5f: 56 push %esi <== NOT EXECUTED 10ca60: 53 push %ebx <== NOT EXECUTED 10ca61: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10ca64: 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 ) 10ca67: 85 db test %ebx,%ebx <== NOT EXECUTED 10ca69: 74 06 je 10ca71 <_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 ) { 10ca6b: 83 7b 34 01 cmpl $0x1,0x34(%ebx) <== NOT EXECUTED 10ca6f: 74 07 je 10ca78 <_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 ); } } 10ca71: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ca74: 5b pop %ebx <== NOT EXECUTED 10ca75: 5e pop %esi <== NOT EXECUTED 10ca76: c9 leave <== NOT EXECUTED 10ca77: 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 ); 10ca78: 9c pushf <== NOT EXECUTED 10ca79: fa cli <== NOT EXECUTED 10ca7a: 5e pop %esi <== NOT EXECUTED if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10ca7b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10ca7e: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax) <== NOT EXECUTED 10ca85: 75 09 jne 10ca90 <_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 ); 10ca87: 56 push %esi <== NOT EXECUTED 10ca88: 9d popf <== NOT EXECUTED } } 10ca89: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10ca8c: 5b pop %ebx <== NOT EXECUTED 10ca8d: 5e pop %esi <== NOT EXECUTED 10ca8e: c9 leave <== NOT EXECUTED 10ca8f: 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 10ca90: 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 ); 10ca97: 52 push %edx <== NOT EXECUTED 10ca98: 6a 01 push $0x1 <== NOT EXECUTED 10ca9a: 50 push %eax <== NOT EXECUTED 10ca9b: 53 push %ebx <== NOT EXECUTED 10ca9c: e8 73 2b 00 00 call 10f614 <_Thread_queue_Extract_priority_helper> <== NOT EXECUTED (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10caa1: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10caa4: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10caa7: 50 push %eax <== NOT EXECUTED 10caa8: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10caab: 53 push %ebx <== NOT EXECUTED 10caac: e8 4f fd ff ff call 10c800 <_Thread_queue_Enqueue_priority> <== NOT EXECUTED 10cab1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cab4: eb d1 jmp 10ca87 <_Thread_queue_Requeue+0x2b> <== NOT EXECUTED 0010cab8 <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 10cab8: 55 push %ebp <== NOT EXECUTED 10cab9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cabb: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10cabe: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10cac1: 50 push %eax <== NOT EXECUTED 10cac2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10cac5: e8 02 f8 ff ff call 10c2cc <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10caca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cacd: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 10cad0: 85 d2 test %edx,%edx <== NOT EXECUTED 10cad2: 75 17 jne 10caeb <_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 ); 10cad4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cad7: 50 push %eax <== NOT EXECUTED 10cad8: e8 fb 2b 00 00 call 10f6d8 <_Thread_queue_Process_timeout> <== NOT EXECUTED 10cadd: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10cae2: 48 dec %eax <== NOT EXECUTED 10cae3: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED 10cae8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Unnest_dispatch(); break; } } 10caeb: c9 leave <== NOT EXECUTED 10caec: c3 ret <== NOT EXECUTED 0010ecb0 <_Timer_Manager_initialization>: */ void _Timer_Manager_initialization( uint32_t maximum_timers ) { 10ecb0: 55 push %ebp <== NOT EXECUTED 10ecb1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ecb3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Objects_Initialize_information( 10ecb6: 6a 04 push $0x4 <== NOT EXECUTED 10ecb8: 6a 00 push $0x0 <== NOT EXECUTED 10ecba: 6a 3c push $0x3c <== NOT EXECUTED 10ecbc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10ecbf: 6a 02 push $0x2 <== NOT EXECUTED 10ecc1: 6a 02 push $0x2 <== NOT EXECUTED 10ecc3: 68 00 ef 11 00 push $0x11ef00 <== NOT EXECUTED 10ecc8: e8 fb cd ff ff call 10bac8 <_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; 10eccd: c7 05 44 ef 11 00 00 movl $0x0,0x11ef44 <== NOT EXECUTED 10ecd4: 00 00 00 <== NOT EXECUTED _Timer_Server_schedule_operation = NULL; 10ecd7: c7 05 40 ef 11 00 00 movl $0x0,0x11ef40 <== NOT EXECUTED 10ecde: 00 00 00 <== NOT EXECUTED 10ece1: 83 c4 20 add $0x20,%esp <== NOT EXECUTED } 10ece4: c9 leave <== NOT EXECUTED 10ece5: 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 64 5c 13 00 mov 0x135c64,%eax <== NOT EXECUTED 114c7d: a3 50 5a 13 00 mov %eax,0x135a50 <== NOT EXECUTED _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 114c82: a1 8c 5b 13 00 mov 0x135b8c,%eax <== NOT EXECUTED 114c87: a3 4c 5a 13 00 mov %eax,0x135a4c <== 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 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 114c91: 40 inc %eax <== NOT EXECUTED 114c92: a3 f8 5a 13 00 mov %eax,0x135af8 <== 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 3f 27 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 114ca1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 114ca4: a1 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 114ca9: 40 inc %eax <== NOT EXECUTED 114caa: a3 f8 5a 13 00 mov %eax,0x135af8 <== 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 a4 5e 13 00 pushl 0x135ea4 <== NOT EXECUTED 114cba: e8 19 31 00 00 call 117dd8 <_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 40 5a 13 00 mov 0x135a40,%edx <== NOT EXECUTED _Timer_Server_reset_ticks_timer(); 114cc5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114cc8: 81 fa 44 5a 13 00 cmp $0x135a44,%edx <== NOT EXECUTED 114cce: 74 1f je 114cef <_Timer_Server_body+0x93> <== NOT EXECUTED 114cd0: a1 a4 5e 13 00 mov 0x135ea4,%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 dc 5b 13 00 push $0x135bdc <== NOT EXECUTED 114ce7: e8 bc 39 00 00 call 1186a8 <_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 54 5a 13 00 mov 0x135a54,%eax <== NOT EXECUTED _Timer_Server_reset_seconds_timer(); 114cf4: 3d 58 5a 13 00 cmp $0x135a58,%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 8c 5a 13 00 mov %eax,0x135a8c <== NOT EXECUTED size_t size ); 114d03: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 114d06: 68 80 5a 13 00 push $0x135a80 <== NOT EXECUTED 114d0b: 68 d0 5b 13 00 push $0x135bd0 <== NOT EXECUTED 114d10: e8 93 39 00 00 call 1186a8 <_Watchdog_Insert> <== NOT EXECUTED 114d15: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 114d18: e8 c3 26 00 00 call 1173e0 <_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 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 114d22: 40 inc %eax <== NOT EXECUTED 114d23: a3 f8 5a 13 00 mov %eax,0x135af8 <== 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 a4 5e 13 00 mov 0x135ea4,%eax <== NOT EXECUTED 114d30: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 114d33: 50 push %eax <== NOT EXECUTED 114d34: e8 9f 3a 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED _Timer_Server_stop_seconds_timer(); 114d39: c7 04 24 80 5a 13 00 movl $0x135a80,(%esp) <== NOT EXECUTED 114d40: e8 93 3a 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED ) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 114d45: 8b 15 64 5c 13 00 mov 0x135c64,%edx <== NOT EXECUTED if ( snapshot >= _Timer_Server_ticks_last_time ) 114d4b: a1 50 5a 13 00 mov 0x135a50,%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 50 5a 13 00 mov %edx,0x135a50 <== 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 40 5a 13 00 push $0x135a40 <== NOT EXECUTED 114d6b: e8 a4 38 00 00 call 118614 <_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 8c 5b 13 00 mov 0x135b8c,%ebx <== NOT EXECUTED if ( snapshot > _Timer_Server_seconds_last_time ) { 114d76: a1 4c 5a 13 00 mov 0x135a4c,%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 4c 5a 13 00 mov %ebx,0x135a4c <== 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 4c 26 00 00 call 1173e0 <_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 54 5a 13 00 push $0x135a54 <== NOT EXECUTED 114de8: e8 27 38 00 00 call 118614 <_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 54 5a 13 00 push $0x135a54 <== NOT EXECUTED 114dff: e8 94 37 00 00 call 118598 <_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 60 5a 13 00 push $0x135a60 <== NOT EXECUTED 114c16: e8 69 08 00 00 call 115484 <_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 40 5a 13 00 push $0x135a40 <== NOT EXECUTED 114c36: e8 6d 3a 00 00 call 1186a8 <_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 54 5a 13 00 push $0x135a54 <== NOT EXECUTED 114c4c: e8 57 3a 00 00 call 1186a8 <_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 60 5a 13 00 push $0x135a60 <== NOT EXECUTED 114bce: e8 8d 08 00 00 call 115460 <_Chain_Append> <== NOT EXECUTED _Watchdog_Remove( &_Timer_Server->Timer ); 114bd3: a1 a4 5e 13 00 mov 0x135ea4,%eax <== NOT EXECUTED 114bd8: 83 c0 48 add $0x48,%eax <== NOT EXECUTED 114bdb: 89 04 24 mov %eax,(%esp) <== NOT EXECUTED 114bde: e8 f5 3b 00 00 call 1187d8 <_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 a4 5e 13 00 mov 0x135ea4,%eax <== NOT EXECUTED 114bec: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 114bef: e8 54 26 00 00 call 117248 <_Thread_Delay_ended> <== NOT EXECUTED 114bf4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 114bf7: c9 leave <== NOT EXECUTED 114bf8: c3 ret <== NOT EXECUTED 0010ced8 <_Timespec_Add_to>: uint32_t _Timespec_Add_to( struct timespec *time, const struct timespec *add ) { 10ced8: 55 push %ebp <== NOT EXECUTED 10ced9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cedb: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10cede: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED uint32_t seconds = add->tv_sec; 10cee1: 8b 08 mov (%eax),%ecx <== NOT EXECUTED /* Add the basics */ time->tv_sec += add->tv_sec; 10cee3: 01 0a add %ecx,(%edx) <== NOT EXECUTED time->tv_nsec += add->tv_nsec; 10cee5: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10cee8: 03 42 04 add 0x4(%edx),%eax <== NOT EXECUTED 10ceeb: 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 ) { 10ceee: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 10cef3: 76 15 jbe 10cf0a <_Timespec_Add_to+0x32> <== NOT EXECUTED 10cef5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND; 10cef8: 2d 00 ca 9a 3b sub $0x3b9aca00,%eax <== NOT EXECUTED 10cefd: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED time->tv_sec++; 10cf00: ff 02 incl (%edx) <== NOT EXECUTED seconds++; 10cf02: 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 ) { 10cf03: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 10cf08: 77 ee ja 10cef8 <_Timespec_Add_to+0x20> <== NOT EXECUTED time->tv_sec++; seconds++; } return seconds; } 10cf0a: 89 c8 mov %ecx,%eax <== NOT EXECUTED 10cf0c: c9 leave <== NOT EXECUTED 10cf0d: c3 ret <== NOT EXECUTED 0010e594 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 10e594: 55 push %ebp <== NOT EXECUTED 10e595: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e597: 57 push %edi <== NOT EXECUTED 10e598: 56 push %esi <== NOT EXECUTED 10e599: 53 push %ebx <== NOT EXECUTED 10e59a: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10e59d: 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; 10e5a0: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10e5a2: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED left += lhs->tv_nsec; 10e5a5: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10e5a8: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10e5ab: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx <== NOT EXECUTED 10e5b0: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10e5b3: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 10e5b5: f7 e9 imul %ecx <== NOT EXECUTED 10e5b7: 89 c6 mov %eax,%esi <== NOT EXECUTED 10e5b9: 89 d7 mov %edx,%edi <== NOT EXECUTED right += rhs->tv_nsec; 10e5bb: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10e5be: 99 cltd <== NOT EXECUTED 10e5bf: 01 c6 add %eax,%esi <== NOT EXECUTED 10e5c1: 11 d7 adc %edx,%edi <== NOT EXECUTED if ( right == 0 ) { 10e5c3: 89 f8 mov %edi,%eax <== NOT EXECUTED 10e5c5: 09 f0 or %esi,%eax <== NOT EXECUTED 10e5c7: 74 77 je 10e640 <_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; 10e5c9: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10e5cc: f7 e9 imul %ecx <== NOT EXECUTED 10e5ce: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED 10e5d1: 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; 10e5d4: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 10e5d7: 99 cltd <== NOT EXECUTED 10e5d8: 01 45 e0 add %eax,-0x20(%ebp) <== NOT EXECUTED 10e5db: 11 55 e4 adc %edx,-0x1c(%ebp) <== NOT EXECUTED 10e5de: 69 5d e4 a0 86 01 00 imul $0x186a0,-0x1c(%ebp),%ebx <== NOT EXECUTED 10e5e5: b9 a0 86 01 00 mov $0x186a0,%ecx <== NOT EXECUTED 10e5ea: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 10e5ed: f7 e1 mul %ecx <== NOT EXECUTED 10e5ef: 89 45 d0 mov %eax,-0x30(%ebp) <== NOT EXECUTED 10e5f2: 01 da add %ebx,%edx <== NOT EXECUTED 10e5f4: 89 55 d4 mov %edx,-0x2c(%ebp) <== NOT EXECUTED 10e5f7: 57 push %edi <== NOT EXECUTED 10e5f8: 56 push %esi <== NOT EXECUTED 10e5f9: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 10e5fc: ff 75 d0 pushl -0x30(%ebp) <== NOT EXECUTED 10e5ff: e8 94 a8 00 00 call 118e98 <__udivdi3> <== NOT EXECUTED 10e604: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e607: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10e609: 89 d6 mov %edx,%esi <== NOT EXECUTED *ival_percentage = answer / 1000; 10e60b: 6a 00 push $0x0 <== NOT EXECUTED 10e60d: 68 e8 03 00 00 push $0x3e8 <== NOT EXECUTED 10e612: 52 push %edx <== NOT EXECUTED 10e613: 50 push %eax <== NOT EXECUTED 10e614: e8 7f a8 00 00 call 118e98 <__udivdi3> <== NOT EXECUTED 10e619: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e61c: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10e61f: 89 01 mov %eax,(%ecx) <== NOT EXECUTED *fval_percentage = answer % 1000; 10e621: 6a 00 push $0x0 <== NOT EXECUTED 10e623: 68 e8 03 00 00 push $0x3e8 <== NOT EXECUTED 10e628: 56 push %esi <== NOT EXECUTED 10e629: 53 push %ebx <== NOT EXECUTED 10e62a: e8 75 a9 00 00 call 118fa4 <__umoddi3> <== NOT EXECUTED 10e62f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e632: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 10e635: 89 03 mov %eax,(%ebx) <== NOT EXECUTED } 10e637: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e63a: 5b pop %ebx <== NOT EXECUTED 10e63b: 5e pop %esi <== NOT EXECUTED 10e63c: 5f pop %edi <== NOT EXECUTED 10e63d: c9 leave <== NOT EXECUTED 10e63e: c3 ret <== NOT EXECUTED 10e63f: 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; 10e640: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10e643: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED *fval_percentage = 0; 10e649: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10e64c: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED answer = (left * 100000) / right; *ival_percentage = answer / 1000; *fval_percentage = answer % 1000; } 10e652: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e655: 5b pop %ebx <== NOT EXECUTED 10e656: 5e pop %esi <== NOT EXECUTED 10e657: 5f pop %edi <== NOT EXECUTED 10e658: c9 leave <== NOT EXECUTED 10e659: c3 ret <== NOT EXECUTED 00127030 <_Timespec_Divide_by_integer>: void _Timespec_Divide_by_integer( const struct timespec *time, uint32_t iterations, struct timespec *result ) { 127030: 55 push %ebp <== NOT EXECUTED 127031: 89 e5 mov %esp,%ebp <== NOT EXECUTED 127033: 57 push %edi <== NOT EXECUTED 127034: 56 push %esi <== NOT EXECUTED 127035: 53 push %ebx <== NOT EXECUTED 127036: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 127039: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 12703c: 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; 12703f: 8b 06 mov (%esi),%eax <== NOT EXECUTED 127041: 99 cltd <== NOT EXECUTED t *= TOD_NANOSECONDS_PER_SECOND; 127042: 69 da 00 ca 9a 3b imul $0x3b9aca00,%edx,%ebx <== NOT EXECUTED 127048: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx <== NOT EXECUTED 12704d: f7 e1 mul %ecx <== NOT EXECUTED 12704f: 8d 14 13 lea (%ebx,%edx,1),%edx <== NOT EXECUTED t += time->tv_nsec; 127052: 8b 4e 04 mov 0x4(%esi),%ecx <== NOT EXECUTED 127055: 89 cb mov %ecx,%ebx <== NOT EXECUTED 127057: c1 fb 1f sar $0x1f,%ebx <== NOT EXECUTED 12705a: 01 c8 add %ecx,%eax <== NOT EXECUTED 12705c: 11 da adc %ebx,%edx <== NOT EXECUTED /* * Divide to get nanoseconds per iteration */ t /= iterations; 12705e: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 127061: 31 db xor %ebx,%ebx <== NOT EXECUTED 127063: 53 push %ebx <== NOT EXECUTED 127064: 51 push %ecx <== NOT EXECUTED 127065: 52 push %edx <== NOT EXECUTED 127066: 50 push %eax <== NOT EXECUTED 127067: e8 b0 7b 01 00 call 13ec1c <__udivdi3> <== NOT EXECUTED 12706c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12706f: 89 c3 mov %eax,%ebx <== NOT EXECUTED 127071: 89 d6 mov %edx,%esi <== NOT EXECUTED /* * Put it back in the timespec result */ result->tv_sec = t / TOD_NANOSECONDS_PER_SECOND; 127073: 6a 00 push $0x0 <== NOT EXECUTED 127075: 68 00 ca 9a 3b push $0x3b9aca00 <== NOT EXECUTED 12707a: 52 push %edx <== NOT EXECUTED 12707b: 50 push %eax <== NOT EXECUTED 12707c: e8 9b 7b 01 00 call 13ec1c <__udivdi3> <== NOT EXECUTED 127081: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 127084: 89 07 mov %eax,(%edi) <== NOT EXECUTED result->tv_nsec = t % TOD_NANOSECONDS_PER_SECOND; 127086: 6a 00 push $0x0 <== NOT EXECUTED 127088: 68 00 ca 9a 3b push $0x3b9aca00 <== NOT EXECUTED 12708d: 56 push %esi <== NOT EXECUTED 12708e: 53 push %ebx <== NOT EXECUTED 12708f: e8 94 7c 01 00 call 13ed28 <__umoddi3> <== NOT EXECUTED 127094: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 127097: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED } 12709a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12709d: 5b pop %ebx <== NOT EXECUTED 12709e: 5e pop %esi <== NOT EXECUTED 12709f: 5f pop %edi <== NOT EXECUTED 1270a0: c9 leave <== NOT EXECUTED 1270a1: c3 ret <== NOT EXECUTED 00116900 <_Timespec_From_ticks>: void _Timespec_From_ticks( uint32_t ticks, struct timespec *time ) { 116900: 55 push %ebp <== NOT EXECUTED 116901: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116903: 53 push %ebx <== NOT EXECUTED 116904: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 116907: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED uint32_t usecs; usecs = ticks * _TOD_Microseconds_per_tick; 11690a: 0f af 1d a0 cb 12 00 imul 0x12cba0,%ebx <== NOT EXECUTED time->tv_sec = usecs / TOD_MICROSECONDS_PER_SECOND; 116911: ba 83 de 1b 43 mov $0x431bde83,%edx <== NOT EXECUTED 116916: 89 d8 mov %ebx,%eax <== NOT EXECUTED 116918: f7 e2 mul %edx <== NOT EXECUTED 11691a: c1 ea 12 shr $0x12,%edx <== NOT EXECUTED 11691d: 89 11 mov %edx,(%ecx) <== NOT EXECUTED time->tv_nsec = (usecs % TOD_MICROSECONDS_PER_SECOND) * 11691f: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 116922: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 116925: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 116928: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 11692b: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 11692e: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 116931: c1 e2 06 shl $0x6,%edx <== NOT EXECUTED 116934: 29 d3 sub %edx,%ebx <== NOT EXECUTED 116936: 8d 04 9b lea (%ebx,%ebx,4),%eax <== NOT EXECUTED 116939: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 11693c: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 11693f: c1 e0 03 shl $0x3,%eax <== NOT EXECUTED 116942: 89 41 04 mov %eax,0x4(%ecx) <== NOT EXECUTED TOD_NANOSECONDS_PER_MICROSECOND; } 116945: 5b pop %ebx <== NOT EXECUTED 116946: c9 leave <== NOT EXECUTED 116947: c3 ret <== NOT EXECUTED 0010e9c4 <_Timespec_Greater_than>: bool _Timespec_Greater_than( const struct timespec *lhs, const struct timespec *rhs ) { 10e9c4: 55 push %ebp <== NOT EXECUTED 10e9c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e9c7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10e9ca: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED if ( lhs->tv_sec > rhs->tv_sec ) 10e9cd: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10e9cf: 39 02 cmp %eax,(%edx) <== NOT EXECUTED 10e9d1: 7f 11 jg 10e9e4 <_Timespec_Greater_than+0x20> <== NOT EXECUTED return TRUE; if ( lhs->tv_sec < rhs->tv_sec ) 10e9d3: 7c 0b jl 10e9e0 <_Timespec_Greater_than+0x1c> <== NOT EXECUTED return FALSE; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec > rhs->tv_nsec ) 10e9d5: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10e9d8: 3b 41 04 cmp 0x4(%ecx),%eax <== NOT EXECUTED 10e9db: 0f 9f c0 setg %al <== NOT EXECUTED return TRUE; return FALSE; } 10e9de: c9 leave <== NOT EXECUTED 10e9df: c3 ret <== NOT EXECUTED ) { if ( lhs->tv_sec > rhs->tv_sec ) return TRUE; if ( lhs->tv_sec < rhs->tv_sec ) 10e9e0: 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; } 10e9e2: c9 leave <== NOT EXECUTED 10e9e3: c3 ret <== NOT EXECUTED bool _Timespec_Greater_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec > rhs->tv_sec ) 10e9e4: 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; } 10e9e6: c9 leave <== NOT EXECUTED 10e9e7: c3 ret <== NOT EXECUTED 00116948 <_Timespec_Is_valid>: #include bool _Timespec_Is_valid( const struct timespec *time ) { 116948: 55 push %ebp <== NOT EXECUTED 116949: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11694b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !time ) 11694e: 85 c0 test %eax,%eax <== NOT EXECUTED 116950: 74 1a je 11696c <_Timespec_Is_valid+0x24> <== NOT EXECUTED return FALSE; if ( time->tv_sec < 0 ) 116952: 8b 10 mov (%eax),%edx <== NOT EXECUTED 116954: 85 d2 test %edx,%edx <== NOT EXECUTED 116956: 78 14 js 11696c <_Timespec_Is_valid+0x24> <== NOT EXECUTED return FALSE; if ( time->tv_nsec < 0 ) 116958: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 11695b: 85 c0 test %eax,%eax <== NOT EXECUTED 11695d: 78 0d js 11696c <_Timespec_Is_valid+0x24> <== NOT EXECUTED 11695f: 3d ff c9 9a 3b cmp $0x3b9ac9ff,%eax <== NOT EXECUTED 116964: 0f 96 c0 setbe %al <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return FALSE; return TRUE; } 116967: c9 leave <== NOT EXECUTED 116968: c3 ret <== NOT EXECUTED 116969: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED return FALSE; if ( time->tv_sec < 0 ) return FALSE; if ( time->tv_nsec < 0 ) 11696c: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) return FALSE; return TRUE; } 11696e: c9 leave <== NOT EXECUTED 11696f: c3 ret <== NOT EXECUTED 0010e9e8 <_Timespec_Less_than>: bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { 10e9e8: 55 push %ebp <== NOT EXECUTED 10e9e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e9eb: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10e9ee: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED if ( lhs->tv_sec < rhs->tv_sec ) 10e9f1: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10e9f3: 39 02 cmp %eax,(%edx) <== NOT EXECUTED 10e9f5: 7c 11 jl 10ea08 <_Timespec_Less_than+0x20> <== NOT EXECUTED return TRUE; if ( lhs->tv_sec > rhs->tv_sec ) 10e9f7: 7f 0b jg 10ea04 <_Timespec_Less_than+0x1c> <== NOT EXECUTED return FALSE; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) 10e9f9: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10e9fc: 3b 41 04 cmp 0x4(%ecx),%eax <== NOT EXECUTED 10e9ff: 0f 9c c0 setl %al <== NOT EXECUTED return TRUE; return FALSE; } 10ea02: c9 leave <== NOT EXECUTED 10ea03: c3 ret <== NOT EXECUTED ) { if ( lhs->tv_sec < rhs->tv_sec ) return TRUE; if ( lhs->tv_sec > rhs->tv_sec ) 10ea04: 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; } 10ea06: c9 leave <== NOT EXECUTED 10ea07: c3 ret <== NOT EXECUTED bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec < rhs->tv_sec ) 10ea08: 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; } 10ea0a: c9 leave <== NOT EXECUTED 10ea0b: c3 ret <== NOT EXECUTED 0010cf10 <_Timespec_Subtract>: void _Timespec_Subtract( const struct timespec *start, const struct timespec *end, struct timespec *result ) { 10cf10: 55 push %ebp <== NOT EXECUTED 10cf11: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cf13: 53 push %ebx <== NOT EXECUTED 10cf14: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10cf17: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10cf1a: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED if (end->tv_nsec < start->tv_nsec) { 10cf1d: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 10cf20: 3b 51 04 cmp 0x4(%ecx),%edx <== NOT EXECUTED 10cf23: 7c 0f jl 10cf34 <_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; 10cf25: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10cf27: 2b 01 sub (%ecx),%eax <== NOT EXECUTED 10cf29: 89 03 mov %eax,(%ebx) <== NOT EXECUTED result->tv_nsec = end->tv_nsec - start->tv_nsec; 10cf2b: 2b 51 04 sub 0x4(%ecx),%edx <== NOT EXECUTED 10cf2e: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED } } 10cf31: 5b pop %ebx <== NOT EXECUTED 10cf32: c9 leave <== NOT EXECUTED 10cf33: c3 ret <== NOT EXECUTED struct timespec *result ) { if (end->tv_nsec < start->tv_nsec) { result->tv_sec = end->tv_sec - start->tv_sec - 1; 10cf34: 8b 00 mov (%eax),%eax <== NOT EXECUTED 10cf36: 48 dec %eax <== NOT EXECUTED 10cf37: 2b 01 sub (%ecx),%eax <== NOT EXECUTED 10cf39: 89 03 mov %eax,(%ebx) <== NOT EXECUTED result->tv_nsec = 10cf3b: 8d 82 00 ca 9a 3b lea 0x3b9aca00(%edx),%eax <== NOT EXECUTED 10cf41: 2b 41 04 sub 0x4(%ecx),%eax <== NOT EXECUTED 10cf44: 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; } } 10cf47: 5b pop %ebx <== NOT EXECUTED 10cf48: c9 leave <== NOT EXECUTED 10cf49: c3 ret <== NOT EXECUTED 00116970 <_Timespec_To_ticks>: */ uint32_t _Timespec_To_ticks( const struct timespec *time ) { 116970: 55 push %ebp <== NOT EXECUTED 116971: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116973: 57 push %edi <== NOT EXECUTED 116974: 56 push %esi <== NOT EXECUTED 116975: 53 push %ebx <== NOT EXECUTED 116976: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 116979: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 11697c: 8b 30 mov (%eax),%esi <== NOT EXECUTED 11697e: 85 f6 test %esi,%esi <== NOT EXECUTED 116980: 74 3e je 1169c0 <_Timespec_To_ticks+0x50> <== NOT EXECUTED 116982: 8b 58 04 mov 0x4(%eax),%ebx <== NOT EXECUTED return 0; ticks = time->tv_sec * TOD_TICKS_PER_SECOND; 116985: 8b 0d a0 cb 12 00 mov 0x12cba0,%ecx <== NOT EXECUTED 11698b: bf 40 42 0f 00 mov $0xf4240,%edi <== NOT EXECUTED 116990: 89 f8 mov %edi,%eax <== NOT EXECUTED 116992: 31 d2 xor %edx,%edx <== NOT EXECUTED 116994: f7 f1 div %ecx <== NOT EXECUTED 116996: 89 c7 mov %eax,%edi <== NOT EXECUTED 116998: 0f af fe imul %esi,%edi <== NOT EXECUTED ticks += (time->tv_nsec / TOD_NANOSECONDS_PER_MICROSECOND) / 11699b: be d3 4d 62 10 mov $0x10624dd3,%esi <== NOT EXECUTED 1169a0: 89 f0 mov %esi,%eax <== NOT EXECUTED 1169a2: f7 e3 mul %ebx <== NOT EXECUTED 1169a4: 89 d3 mov %edx,%ebx <== NOT EXECUTED 1169a6: c1 eb 06 shr $0x6,%ebx <== NOT EXECUTED 1169a9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1169ab: 31 d2 xor %edx,%edx <== NOT EXECUTED 1169ad: f7 f1 div %ecx <== NOT EXECUTED _TOD_Microseconds_per_tick; if (ticks) 1169af: 01 f8 add %edi,%eax <== NOT EXECUTED 1169b1: 75 05 jne 1169b8 <_Timespec_To_ticks+0x48> <== NOT EXECUTED 1169b3: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED return ticks; return 1; } 1169b8: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 1169bb: 5b pop %ebx <== NOT EXECUTED 1169bc: 5e pop %esi <== NOT EXECUTED 1169bd: 5f pop %edi <== NOT EXECUTED 1169be: c9 leave <== NOT EXECUTED 1169bf: c3 ret <== NOT EXECUTED const struct timespec *time ) { uint32_t ticks; if ( (time->tv_sec == 0) && (time->tv_nsec == 0) ) 1169c0: 8b 58 04 mov 0x4(%eax),%ebx <== NOT EXECUTED 1169c3: 85 db test %ebx,%ebx <== NOT EXECUTED 1169c5: 75 be jne 116985 <_Timespec_To_ticks+0x15> <== NOT EXECUTED 1169c7: 31 c0 xor %eax,%eax <== NOT EXECUTED if (ticks) return ticks; return 1; } 1169c9: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 1169cc: 5b pop %ebx <== NOT EXECUTED 1169cd: 5e pop %esi <== NOT EXECUTED 1169ce: 5f pop %edi <== NOT EXECUTED 1169cf: c9 leave <== NOT EXECUTED 1169d0: c3 ret <== NOT EXECUTED 0010f824 <_User_extensions_Add_API_set>: */ void _User_extensions_Add_API_set ( User_extensions_Control *the_extension ) { 10f824: 55 push %ebp <== NOT EXECUTED 10f825: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f827: 53 push %ebx <== NOT EXECUTED 10f828: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f82b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Chain_Append( &_User_extensions_List, &the_extension->Node ); 10f82e: 53 push %ebx <== NOT EXECUTED 10f82f: 68 4c ec 11 00 push $0x11ec4c <== NOT EXECUTED 10f834: e8 ff b4 ff ff call 10ad38 <_Chain_Append> <== NOT EXECUTED /* * If a switch handler is present, append it to the switch chain. */ if ( the_extension->Callouts.thread_switch != NULL ) { 10f839: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 10f83c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f83f: 85 c0 test %eax,%eax <== NOT EXECUTED 10f841: 74 17 je 10f85a <_User_extensions_Add_API_set+0x36> <== NOT EXECUTED the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch; 10f843: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _Chain_Append( 10f846: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f849: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10f84c: 50 push %eax <== NOT EXECUTED 10f84d: 68 fc e9 11 00 push $0x11e9fc <== NOT EXECUTED 10f852: e8 e1 b4 ff ff call 10ad38 <_Chain_Append> <== NOT EXECUTED 10f857: 83 c4 10 add $0x10,%esp <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10f85a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f85d: c9 leave <== NOT EXECUTED 10f85e: c3 ret <== NOT EXECUTED 0010f860 <_User_extensions_Add_set>: void _User_extensions_Add_set ( User_extensions_Control *the_extension, User_extensions_Table *extension_table ) { 10f860: 55 push %ebp <== NOT EXECUTED 10f861: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f863: 57 push %edi <== NOT EXECUTED 10f864: 56 push %esi <== NOT EXECUTED 10f865: 53 push %ebx <== NOT EXECUTED 10f866: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10f869: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 10f86c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f86f: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED the_extension->Callouts = *extension_table; 10f872: 8d 7b 14 lea 0x14(%ebx),%edi <== NOT EXECUTED 10f875: b9 08 00 00 00 mov $0x8,%ecx <== NOT EXECUTED 10f87a: 89 c6 mov %eax,%esi <== NOT EXECUTED 10f87c: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Chain_Append( &_User_extensions_List, &the_extension->Node ); 10f87e: 53 push %ebx <== NOT EXECUTED 10f87f: 68 4c ec 11 00 push $0x11ec4c <== NOT EXECUTED 10f884: e8 af b4 ff ff call 10ad38 <_Chain_Append> <== NOT EXECUTED /* * If a switch handler is present, append it to the switch chain. */ if ( extension_table->thread_switch != NULL ) { 10f889: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10f88c: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10f88f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f892: 85 c0 test %eax,%eax <== NOT EXECUTED 10f894: 74 1e je 10f8b4 <_User_extensions_Add_set+0x54> <== NOT EXECUTED the_extension->Switch.thread_switch = extension_table->thread_switch; 10f896: 89 43 10 mov %eax,0x10(%ebx) <== NOT EXECUTED _Chain_Append( 10f899: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10f89c: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10f89f: c7 45 08 fc e9 11 00 movl $0x11e9fc,0x8(%ebp) <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10f8a6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f8a9: 5b pop %ebx <== NOT EXECUTED 10f8aa: 5e pop %esi <== NOT EXECUTED 10f8ab: 5f pop %edi <== NOT EXECUTED 10f8ac: 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( 10f8ad: e9 86 b4 ff ff jmp 10ad38 <_Chain_Append> <== NOT EXECUTED 10f8b2: 66 90 xchg %ax,%ax <== NOT EXECUTED &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10f8b4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f8b7: 5b pop %ebx <== NOT EXECUTED 10f8b8: 5e pop %esi <== NOT EXECUTED 10f8b9: 5f pop %edi <== NOT EXECUTED 10f8ba: c9 leave <== NOT EXECUTED 10f8bb: c3 ret <== NOT EXECUTED 0010d068 <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10d068: 55 push %ebp <== NOT EXECUTED 10d069: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d06b: 57 push %edi <== NOT EXECUTED 10d06c: 56 push %esi <== NOT EXECUTED 10d06d: 53 push %ebx <== NOT EXECUTED 10d06e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d071: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10d074: 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 ; 10d077: 8b 1d 54 ec 11 00 mov 0x11ec54,%ebx <== NOT EXECUTED !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d07d: 81 fb 4c ec 11 00 cmp $0x11ec4c,%ebx <== NOT EXECUTED 10d083: 74 20 je 10d0a5 <_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 ); 10d085: 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 ) 10d088: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10d08b: 85 c0 test %eax,%eax <== NOT EXECUTED 10d08d: 74 0b je 10d09a <_User_extensions_Fatal+0x32> <== NOT EXECUTED (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10d08f: 52 push %edx <== NOT EXECUTED 10d090: 57 push %edi <== NOT EXECUTED 10d091: 56 push %esi <== NOT EXECUTED 10d092: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d095: ff d0 call *%eax <== NOT EXECUTED 10d097: 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 ) { 10d09a: 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 ) ; 10d09d: 81 fb 4c ec 11 00 cmp $0x11ec4c,%ebx <== NOT EXECUTED 10d0a3: 75 e3 jne 10d088 <_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 ); } } 10d0a5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d0a8: 5b pop %ebx <== NOT EXECUTED 10d0a9: 5e pop %esi <== NOT EXECUTED 10d0aa: 5f pop %edi <== NOT EXECUTED 10d0ab: c9 leave <== NOT EXECUTED 10d0ac: c3 ret <== NOT EXECUTED 0010cf4c <_User_extensions_Handler_initialization>: void _User_extensions_Handler_initialization ( uint32_t number_of_extensions, User_extensions_Table *initial_extensions ) { 10cf4c: 55 push %ebp <== NOT EXECUTED 10cf4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cf4f: 57 push %edi <== NOT EXECUTED 10cf50: 56 push %esi <== NOT EXECUTED 10cf51: 53 push %ebx <== NOT EXECUTED 10cf52: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cf55: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10cf58: c7 05 4c ec 11 00 50 movl $0x11ec50,0x11ec4c <== NOT EXECUTED 10cf5f: ec 11 00 <== NOT EXECUTED 10cf62: c7 05 50 ec 11 00 00 movl $0x0,0x11ec50 <== NOT EXECUTED 10cf69: 00 00 00 <== NOT EXECUTED 10cf6c: c7 05 54 ec 11 00 4c movl $0x11ec4c,0x11ec54 <== NOT EXECUTED 10cf73: ec 11 00 <== NOT EXECUTED 10cf76: c7 05 fc e9 11 00 00 movl $0x11ea00,0x11e9fc <== NOT EXECUTED 10cf7d: ea 11 00 <== NOT EXECUTED 10cf80: c7 05 00 ea 11 00 00 movl $0x0,0x11ea00 <== NOT EXECUTED 10cf87: 00 00 00 <== NOT EXECUTED 10cf8a: c7 05 04 ea 11 00 fc movl $0x11e9fc,0x11ea04 <== NOT EXECUTED 10cf91: e9 11 00 <== NOT EXECUTED uint32_t i; _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10cf94: 85 f6 test %esi,%esi <== NOT EXECUTED 10cf96: 74 50 je 10cfe8 <_User_extensions_Handler_initialization+0x9c> <== NOT EXECUTED extension = (User_extensions_Control *) 10cf98: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10cf9b: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10cf9e: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 10cfa1: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 10cfa8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cfab: 53 push %ebx <== NOT EXECUTED 10cfac: e8 43 04 00 00 call 10d3f4 <_Workspace_Allocate_or_fatal_error> <== NOT EXECUTED 10cfb1: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED _Workspace_Allocate_or_fatal_error( number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10cfb4: 31 c0 xor %eax,%eax <== NOT EXECUTED 10cfb6: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 10cfb9: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10cfbb: 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++ ) { 10cfbd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cfc0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10cfc3: 85 c0 test %eax,%eax <== NOT EXECUTED 10cfc5: 74 21 je 10cfe8 <_User_extensions_Handler_initialization+0x9c> <== NOT EXECUTED 10cfc7: 31 db xor %ebx,%ebx <== NOT EXECUTED 10cfc9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED _User_extensions_Add_set (extension, &initial_extensions[i]); 10cfcc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10cfcf: 56 push %esi <== NOT EXECUTED 10cfd0: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10cfd3: e8 88 28 00 00 call 10f860 <_User_extensions_Add_set> <== NOT EXECUTED extension++; 10cfd8: 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++ ) { 10cfdc: 43 inc %ebx <== NOT EXECUTED 10cfdd: 83 c6 20 add $0x20,%esi <== NOT EXECUTED 10cfe0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10cfe3: 39 5d 08 cmp %ebx,0x8(%ebp) <== NOT EXECUTED 10cfe6: 77 e4 ja 10cfcc <_User_extensions_Handler_initialization+0x80> <== NOT EXECUTED _User_extensions_Add_set (extension, &initial_extensions[i]); extension++; } } } 10cfe8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10cfeb: 5b pop %ebx <== NOT EXECUTED 10cfec: 5e pop %esi <== NOT EXECUTED 10cfed: 5f pop %edi <== NOT EXECUTED 10cfee: c9 leave <== NOT EXECUTED 10cfef: c3 ret <== NOT EXECUTED 00111e84 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 111e84: 55 push %ebp <== NOT EXECUTED 111e85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 111e87: 53 push %ebx <== NOT EXECUTED 111e88: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 111e8b: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED _Chain_Extract( &the_extension->Node ); 111e8e: 53 push %ebx <== NOT EXECUTED 111e8f: e8 f4 3e 00 00 call 115d88 <_Chain_Extract> <== NOT EXECUTED /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 111e94: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111e97: 8b 43 24 mov 0x24(%ebx),%eax <== NOT EXECUTED 111e9a: 85 c0 test %eax,%eax <== NOT EXECUTED 111e9c: 74 12 je 111eb0 <_User_extensions_Remove_set+0x2c> <== NOT EXECUTED _Chain_Extract( &the_extension->Switch.Node ); 111e9e: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 111ea1: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 111ea4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111ea7: 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 ); 111ea8: e9 db 3e 00 00 jmp 115d88 <_Chain_Extract> <== NOT EXECUTED 111ead: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } 111eb0: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111eb3: c9 leave <== NOT EXECUTED 111eb4: c3 ret <== NOT EXECUTED 0010cff0 <_User_extensions_Thread_begin>: */ void _User_extensions_Thread_begin ( Thread_Control *executing ) { 10cff0: 55 push %ebp <== NOT EXECUTED 10cff1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10cff3: 56 push %esi <== NOT EXECUTED 10cff4: 53 push %ebx <== NOT EXECUTED 10cff5: 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 ; 10cff8: 8b 1d 4c ec 11 00 mov 0x11ec4c,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10cffe: 81 fb 50 ec 11 00 cmp $0x11ec50,%ebx <== NOT EXECUTED 10d004: 74 1c je 10d022 <_User_extensions_Thread_begin+0x32> <== NOT EXECUTED 10d006: 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 ) 10d008: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10d00b: 85 c0 test %eax,%eax <== NOT EXECUTED 10d00d: 74 09 je 10d018 <_User_extensions_Thread_begin+0x28> <== NOT EXECUTED (*the_extension->Callouts.thread_begin)( executing ); 10d00f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d012: 56 push %esi <== NOT EXECUTED 10d013: ff d0 call *%eax <== NOT EXECUTED 10d015: 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 ) { 10d018: 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 ) ; 10d01a: 81 fb 50 ec 11 00 cmp $0x11ec50,%ebx <== NOT EXECUTED 10d020: 75 e6 jne 10d008 <_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 ); } } 10d022: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d025: 5b pop %ebx <== NOT EXECUTED 10d026: 5e pop %esi <== NOT EXECUTED 10d027: c9 leave <== NOT EXECUTED 10d028: c3 ret <== NOT EXECUTED 0010d0b0 <_User_extensions_Thread_create>: */ bool _User_extensions_Thread_create ( Thread_Control *the_thread ) { 10d0b0: 55 push %ebp <== NOT EXECUTED 10d0b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d0b3: 56 push %esi <== NOT EXECUTED 10d0b4: 53 push %ebx <== NOT EXECUTED 10d0b5: 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 ; 10d0b8: 8b 1d 4c ec 11 00 mov 0x11ec4c,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d0be: 81 fb 50 ec 11 00 cmp $0x11ec50,%ebx <== NOT EXECUTED 10d0c4: 74 26 je 10d0ec <_User_extensions_Thread_create+0x3c> <== NOT EXECUTED 10d0c6: 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 ) { 10d0c8: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10d0cb: 85 c0 test %eax,%eax <== NOT EXECUTED 10d0cd: 74 13 je 10d0e2 <_User_extensions_Thread_create+0x32> <== NOT EXECUTED status = (*the_extension->Callouts.thread_create)( 10d0cf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d0d2: 56 push %esi <== NOT EXECUTED 10d0d3: ff 35 bc ea 11 00 pushl 0x11eabc <== NOT EXECUTED 10d0d9: ff d0 call *%eax <== NOT EXECUTED _Thread_Executing, the_thread ); if ( !status ) 10d0db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d0de: 84 c0 test %al,%al <== NOT EXECUTED 10d0e0: 74 0c je 10d0ee <_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 ) { 10d0e2: 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 ) ; 10d0e4: 81 fb 50 ec 11 00 cmp $0x11ec50,%ebx <== NOT EXECUTED 10d0ea: 75 dc jne 10d0c8 <_User_extensions_Thread_create+0x18> <== NOT EXECUTED 10d0ec: b0 01 mov $0x1,%al <== NOT EXECUTED return FALSE; } } return TRUE; } 10d0ee: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d0f1: 5b pop %ebx <== NOT EXECUTED 10d0f2: 5e pop %esi <== NOT EXECUTED 10d0f3: c9 leave <== NOT EXECUTED 10d0f4: c3 ret <== NOT EXECUTED 0010d0f8 <_User_extensions_Thread_delete>: */ void _User_extensions_Thread_delete ( Thread_Control *the_thread ) { 10d0f8: 55 push %ebp <== NOT EXECUTED 10d0f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d0fb: 56 push %esi <== NOT EXECUTED 10d0fc: 53 push %ebx <== NOT EXECUTED 10d0fd: 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 ; 10d100: 8b 1d 54 ec 11 00 mov 0x11ec54,%ebx <== NOT EXECUTED !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d106: 81 fb 4c ec 11 00 cmp $0x11ec4c,%ebx <== NOT EXECUTED 10d10c: 74 23 je 10d131 <_User_extensions_Thread_delete+0x39> <== NOT EXECUTED 10d10e: 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 ) 10d110: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 10d113: 85 c0 test %eax,%eax <== NOT EXECUTED 10d115: 74 0f je 10d126 <_User_extensions_Thread_delete+0x2e> <== NOT EXECUTED (*the_extension->Callouts.thread_delete)( 10d117: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d11a: 56 push %esi <== NOT EXECUTED 10d11b: ff 35 bc ea 11 00 pushl 0x11eabc <== NOT EXECUTED 10d121: ff d0 call *%eax <== NOT EXECUTED 10d123: 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 ) { 10d126: 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 ) ; 10d129: 81 fb 4c ec 11 00 cmp $0x11ec4c,%ebx <== NOT EXECUTED 10d12f: 75 df jne 10d110 <_User_extensions_Thread_delete+0x18> <== NOT EXECUTED (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10d131: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d134: 5b pop %ebx <== NOT EXECUTED 10d135: 5e pop %esi <== NOT EXECUTED 10d136: c9 leave <== NOT EXECUTED 10d137: c3 ret <== NOT EXECUTED 0010d02c <_User_extensions_Thread_exitted>: */ void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 10d02c: 55 push %ebp <== NOT EXECUTED 10d02d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d02f: 56 push %esi <== NOT EXECUTED 10d030: 53 push %ebx <== NOT EXECUTED 10d031: 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 ; 10d034: 8b 1d 54 ec 11 00 mov 0x11ec54,%ebx <== NOT EXECUTED !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d03a: 81 fb 4c ec 11 00 cmp $0x11ec4c,%ebx <== NOT EXECUTED 10d040: 74 1d je 10d05f <_User_extensions_Thread_exitted+0x33> <== NOT EXECUTED 10d042: 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 ) 10d044: 8b 43 2c mov 0x2c(%ebx),%eax <== NOT EXECUTED 10d047: 85 c0 test %eax,%eax <== NOT EXECUTED 10d049: 74 09 je 10d054 <_User_extensions_Thread_exitted+0x28> <== NOT EXECUTED (*the_extension->Callouts.thread_exitted)( executing ); 10d04b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d04e: 56 push %esi <== NOT EXECUTED 10d04f: ff d0 call *%eax <== NOT EXECUTED 10d051: 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 ) { 10d054: 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 ) ; 10d057: 81 fb 4c ec 11 00 cmp $0x11ec4c,%ebx <== NOT EXECUTED 10d05d: 75 e5 jne 10d044 <_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 ); } } 10d05f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d062: 5b pop %ebx <== NOT EXECUTED 10d063: 5e pop %esi <== NOT EXECUTED 10d064: c9 leave <== NOT EXECUTED 10d065: c3 ret <== NOT EXECUTED 0010dc04 <_User_extensions_Thread_restart>: */ void _User_extensions_Thread_restart ( Thread_Control *the_thread ) { 10dc04: 55 push %ebp <== NOT EXECUTED 10dc05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc07: 56 push %esi <== NOT EXECUTED 10dc08: 53 push %ebx <== NOT EXECUTED 10dc09: 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 ; 10dc0c: 8b 1d 0c 19 12 00 mov 0x12190c,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10dc12: 81 fb 10 19 12 00 cmp $0x121910,%ebx <== NOT EXECUTED 10dc18: 74 22 je 10dc3c <_User_extensions_Thread_restart+0x38> <== NOT EXECUTED 10dc1a: 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 ) 10dc1c: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 10dc1f: 85 c0 test %eax,%eax <== NOT EXECUTED 10dc21: 74 0f je 10dc32 <_User_extensions_Thread_restart+0x2e> <== NOT EXECUTED (*the_extension->Callouts.thread_restart)( 10dc23: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dc26: 56 push %esi <== NOT EXECUTED 10dc27: ff 35 7c 17 12 00 pushl 0x12177c <== NOT EXECUTED 10dc2d: ff d0 call *%eax <== NOT EXECUTED 10dc2f: 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 ) { 10dc32: 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 ) ; 10dc34: 81 fb 10 19 12 00 cmp $0x121910,%ebx <== NOT EXECUTED 10dc3a: 75 e0 jne 10dc1c <_User_extensions_Thread_restart+0x18> <== NOT EXECUTED (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10dc3c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10dc3f: 5b pop %ebx <== NOT EXECUTED 10dc40: 5e pop %esi <== NOT EXECUTED 10dc41: c9 leave <== NOT EXECUTED 10dc42: c3 ret <== NOT EXECUTED 0010d138 <_User_extensions_Thread_start>: */ void _User_extensions_Thread_start ( Thread_Control *the_thread ) { 10d138: 55 push %ebp <== NOT EXECUTED 10d139: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d13b: 56 push %esi <== NOT EXECUTED 10d13c: 53 push %ebx <== NOT EXECUTED 10d13d: 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 ; 10d140: 8b 1d 4c ec 11 00 mov 0x11ec4c,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d146: 81 fb 50 ec 11 00 cmp $0x11ec50,%ebx <== NOT EXECUTED 10d14c: 74 22 je 10d170 <_User_extensions_Thread_start+0x38> <== NOT EXECUTED 10d14e: 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 ) 10d150: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10d153: 85 c0 test %eax,%eax <== NOT EXECUTED 10d155: 74 0f je 10d166 <_User_extensions_Thread_start+0x2e> <== NOT EXECUTED (*the_extension->Callouts.thread_start)( 10d157: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d15a: 56 push %esi <== NOT EXECUTED 10d15b: ff 35 bc ea 11 00 pushl 0x11eabc <== NOT EXECUTED 10d161: ff d0 call *%eax <== NOT EXECUTED 10d163: 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 ) { 10d166: 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 ) ; 10d168: 81 fb 50 ec 11 00 cmp $0x11ec50,%ebx <== NOT EXECUTED 10d16e: 75 e0 jne 10d150 <_User_extensions_Thread_start+0x18> <== NOT EXECUTED (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10d170: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10d173: 5b pop %ebx <== NOT EXECUTED 10d174: 5e pop %esi <== NOT EXECUTED 10d175: c9 leave <== NOT EXECUTED 10d176: c3 ret <== NOT EXECUTED 0010d178 <_User_extensions_Thread_switch>: */ void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) { 10d178: 55 push %ebp <== NOT EXECUTED 10d179: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d17b: 57 push %edi <== NOT EXECUTED 10d17c: 56 push %esi <== NOT EXECUTED 10d17d: 53 push %ebx <== NOT EXECUTED 10d17e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d181: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10d184: 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 ; 10d187: 8b 1d fc e9 11 00 mov 0x11e9fc,%ebx <== NOT EXECUTED !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; 10d18d: 81 fb 00 ea 11 00 cmp $0x11ea00,%ebx <== NOT EXECUTED 10d193: 74 18 je 10d1ad <_User_extensions_Thread_switch+0x35> <== NOT EXECUTED 10d195: 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 ); 10d198: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d19b: 56 push %esi <== NOT EXECUTED 10d19c: 57 push %edi <== NOT EXECUTED 10d19d: 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 ) { 10d1a0: 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 ) ; 10d1a2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d1a5: 81 fb 00 ea 11 00 cmp $0x11ea00,%ebx <== NOT EXECUTED 10d1ab: 75 eb jne 10d198 <_User_extensions_Thread_switch+0x20> <== NOT EXECUTED the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10d1ad: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d1b0: 5b pop %ebx <== NOT EXECUTED 10d1b1: 5e pop %esi <== NOT EXECUTED 10d1b2: 5f pop %edi <== NOT EXECUTED 10d1b3: c9 leave <== NOT EXECUTED 10d1b4: c3 ret <== NOT EXECUTED 0010e960 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10e960: 55 push %ebp <== NOT EXECUTED 10e961: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e963: 57 push %edi <== NOT EXECUTED 10e964: 56 push %esi <== NOT EXECUTED 10e965: 53 push %ebx <== NOT EXECUTED 10e966: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e969: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10e96c: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10e96f: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED ISR_Level level; _ISR_Disable( level ); 10e972: 9c pushf <== NOT EXECUTED 10e973: fa cli <== NOT EXECUTED 10e974: 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( 10e975: 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 10e977: 8d 5f 04 lea 0x4(%edi),%ebx <== NOT EXECUTED 10e97a: 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 ) ) { 10e97d: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10e97f: 74 3f je 10e9c0 <_Watchdog_Adjust+0x60> <== NOT EXECUTED switch ( direction ) { 10e981: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10e983: 75 47 jne 10e9cc <_Watchdog_Adjust+0x6c> <== NOT EXECUTED case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10e985: 85 f6 test %esi,%esi <== NOT EXECUTED 10e987: 74 37 je 10e9c0 <_Watchdog_Adjust+0x60> <== NOT EXECUTED if ( units < _Watchdog_First( header )->delta_interval ) { 10e989: 8b 58 10 mov 0x10(%eax),%ebx <== NOT EXECUTED 10e98c: 39 de cmp %ebx,%esi <== NOT EXECUTED 10e98e: 73 0f jae 10e99f <_Watchdog_Adjust+0x3f> <== NOT EXECUTED 10e990: eb 42 jmp 10e9d4 <_Watchdog_Adjust+0x74> <== NOT EXECUTED 10e992: 66 90 xchg %ax,%ax <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10e994: 29 de sub %ebx,%esi <== NOT EXECUTED 10e996: 74 28 je 10e9c0 <_Watchdog_Adjust+0x60> <== NOT EXECUTED if ( units < _Watchdog_First( header )->delta_interval ) { 10e998: 8b 58 10 mov 0x10(%eax),%ebx <== NOT EXECUTED 10e99b: 39 f3 cmp %esi,%ebx <== NOT EXECUTED 10e99d: 77 35 ja 10e9d4 <_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; 10e99f: c7 40 10 01 00 00 00 movl $0x1,0x10(%eax) <== NOT EXECUTED _ISR_Enable( level ); 10e9a6: 52 push %edx <== NOT EXECUTED 10e9a7: 9d popf <== NOT EXECUTED _Watchdog_Tickle( header ); 10e9a8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e9ab: 57 push %edi <== NOT EXECUTED 10e9ac: e8 c7 01 00 00 call 10eb78 <_Watchdog_Tickle> <== NOT EXECUTED _ISR_Disable( level ); 10e9b1: 9c pushf <== NOT EXECUTED 10e9b2: fa cli <== NOT EXECUTED 10e9b3: 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( 10e9b4: 8b 07 mov (%edi),%eax <== NOT EXECUTED if ( _Chain_Is_empty( header ) ) 10e9b6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e9b9: 39 45 f0 cmp %eax,-0x10(%ebp) <== NOT EXECUTED 10e9bc: 75 d6 jne 10e994 <_Watchdog_Adjust+0x34> <== NOT EXECUTED 10e9be: 66 90 xchg %ax,%ax <== NOT EXECUTED } break; } } _ISR_Enable( level ); 10e9c0: 52 push %edx <== NOT EXECUTED 10e9c1: 9d popf <== NOT EXECUTED } 10e9c2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e9c5: 5b pop %ebx <== NOT EXECUTED 10e9c6: 5e pop %esi <== NOT EXECUTED 10e9c7: 5f pop %edi <== NOT EXECUTED 10e9c8: c9 leave <== NOT EXECUTED 10e9c9: c3 ret <== NOT EXECUTED 10e9ca: 66 90 xchg %ax,%ax <== NOT EXECUTED * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { switch ( direction ) { 10e9cc: 49 dec %ecx <== NOT EXECUTED 10e9cd: 75 f1 jne 10e9c0 <_Watchdog_Adjust+0x60> <== NOT EXECUTED case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10e9cf: 01 70 10 add %esi,0x10(%eax) <== NOT EXECUTED 10e9d2: eb ec jmp 10e9c0 <_Watchdog_Adjust+0x60> <== NOT EXECUTED break; case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; 10e9d4: 29 f3 sub %esi,%ebx <== NOT EXECUTED 10e9d6: 89 58 10 mov %ebx,0x10(%eax) <== NOT EXECUTED 10e9d9: eb e5 jmp 10e9c0 <_Watchdog_Adjust+0x60> <== NOT EXECUTED 00118614 <_Watchdog_Adjust_to_chain>: Chain_Control *header, Watchdog_Interval units_arg, Chain_Control *to_fire ) { 118614: 55 push %ebp <== NOT EXECUTED 118615: 89 e5 mov %esp,%ebp <== NOT EXECUTED 118617: 57 push %edi <== NOT EXECUTED 118618: 56 push %esi <== NOT EXECUTED 118619: 53 push %ebx <== NOT EXECUTED 11861a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11861d: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 118620: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED Watchdog_Interval units = units_arg; ISR_Level level; Chain_Node *node; if ( !units ) { 118623: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 118626: 85 c0 test %eax,%eax <== NOT EXECUTED 118628: 74 6a je 118694 <_Watchdog_Adjust_to_chain+0x80> <== NOT EXECUTED return; } _ISR_Disable( level ); 11862a: 9c pushf <== NOT EXECUTED 11862b: fa cli <== NOT EXECUTED 11862c: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED 11862f: 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 118631: 8d 4b 04 lea 0x4(%ebx),%ecx <== NOT EXECUTED if ( !_Chain_Is_empty( header ) ) { 118634: 39 ca cmp %ecx,%edx <== NOT EXECUTED 118636: 74 58 je 118690 <_Watchdog_Adjust_to_chain+0x7c> <== NOT EXECUTED 118638: 8b 72 10 mov 0x10(%edx),%esi <== NOT EXECUTED 11863b: 8d 47 04 lea 0x4(%edi),%eax <== NOT EXECUTED 11863e: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 118641: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 118644: 89 45 e8 mov %eax,-0x18(%ebp) <== NOT EXECUTED 118647: 90 nop <== NOT EXECUTED while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 118648: 3b 75 e8 cmp -0x18(%ebp),%esi <== NOT EXECUTED 11864b: 77 3c ja 118689 <_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; 11864d: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED 118654: eb 2b jmp 118681 <_Watchdog_Adjust_to_chain+0x6d> <== NOT EXECUTED 118656: 66 90 xchg %ax,%ax <== NOT EXECUTED 118658: 8b 02 mov (%edx),%eax <== NOT EXECUTED 11865a: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 11865c: 89 58 04 mov %ebx,0x4(%eax) <== NOT EXECUTED 11865f: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 118662: 89 02 mov %eax,(%edx) <== NOT EXECUTED 118664: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED 118667: 89 57 08 mov %edx,0x8(%edi) <== NOT EXECUTED 11866a: 89 10 mov %edx,(%eax) <== NOT EXECUTED 11866c: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED do { node = _Chain_Get_unprotected( header ); _Chain_Append_unprotected( to_fire, node ); _ISR_Flash( level ); 11866f: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 118672: 9d popf <== NOT EXECUTED 118673: 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( 118674: 8b 13 mov (%ebx),%edx <== NOT EXECUTED } while ( !_Chain_Is_empty( header ) && _Watchdog_First( header )->delta_interval == 0 ); 118676: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 118678: 74 16 je 118690 <_Watchdog_Adjust_to_chain+0x7c> <== NOT EXECUTED 11867a: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 11867d: 85 c0 test %eax,%eax <== NOT EXECUTED 11867f: 75 1b jne 11869c <_Watchdog_Adjust_to_chain+0x88> <== NOT EXECUTED 118681: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 118683: 75 d3 jne 118658 <_Watchdog_Adjust_to_chain+0x44> <== NOT EXECUTED 118685: 31 d2 xor %edx,%edx <== NOT EXECUTED 118687: eb d6 jmp 11865f <_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; 118689: 2b 75 e8 sub -0x18(%ebp),%esi <== NOT EXECUTED 11868c: 89 72 10 mov %esi,0x10(%edx) <== NOT EXECUTED 11868f: 90 nop <== NOT EXECUTED break; } } } _ISR_Enable( level ); 118690: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 118693: 9d popf <== NOT EXECUTED } 118694: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 118697: 5b pop %ebx <== NOT EXECUTED 118698: 5e pop %esi <== NOT EXECUTED 118699: 5f pop %edi <== NOT EXECUTED 11869a: c9 leave <== NOT EXECUTED 11869b: c3 ret <== NOT EXECUTED return; } _ISR_Disable( level ); if ( !_Chain_Is_empty( header ) ) { while ( units ) { 11869c: 29 75 e8 sub %esi,-0x18(%ebp) <== NOT EXECUTED 11869f: 74 ef je 118690 <_Watchdog_Adjust_to_chain+0x7c> <== NOT EXECUTED 1186a1: 89 c6 mov %eax,%esi <== NOT EXECUTED 1186a3: eb a3 jmp 118648 <_Watchdog_Adjust_to_chain+0x34> <== NOT EXECUTED 0010d288 <_Watchdog_Handler_initialization>: * * Output parameters: NONE */ void _Watchdog_Handler_initialization( void ) { 10d288: 55 push %ebp <== NOT EXECUTED 10d289: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Watchdog_Sync_count = 0; 10d28b: c7 05 60 eb 11 00 00 movl $0x0,0x11eb60 <== NOT EXECUTED 10d292: 00 00 00 <== NOT EXECUTED _Watchdog_Sync_level = 0; 10d295: c7 05 b8 ea 11 00 00 movl $0x0,0x11eab8 <== NOT EXECUTED 10d29c: 00 00 00 <== NOT EXECUTED _Watchdog_Ticks_since_boot = 0; 10d29f: c7 05 64 eb 11 00 00 movl $0x0,0x11eb64 <== NOT EXECUTED 10d2a6: 00 00 00 <== NOT EXECUTED 10d2a9: c7 05 dc ea 11 00 e0 movl $0x11eae0,0x11eadc <== NOT EXECUTED 10d2b0: ea 11 00 <== NOT EXECUTED 10d2b3: c7 05 e0 ea 11 00 00 movl $0x0,0x11eae0 <== NOT EXECUTED 10d2ba: 00 00 00 <== NOT EXECUTED 10d2bd: c7 05 e4 ea 11 00 dc movl $0x11eadc,0x11eae4 <== NOT EXECUTED 10d2c4: ea 11 00 <== NOT EXECUTED 10d2c7: c7 05 d0 ea 11 00 d4 movl $0x11ead4,0x11ead0 <== NOT EXECUTED 10d2ce: ea 11 00 <== NOT EXECUTED 10d2d1: c7 05 d4 ea 11 00 00 movl $0x0,0x11ead4 <== NOT EXECUTED 10d2d8: 00 00 00 <== NOT EXECUTED 10d2db: c7 05 d8 ea 11 00 d0 movl $0x11ead0,0x11ead8 <== NOT EXECUTED 10d2e2: ea 11 00 <== NOT EXECUTED _Chain_Initialize_empty( &_Watchdog_Ticks_chain ); _Chain_Initialize_empty( &_Watchdog_Seconds_chain ); } 10d2e5: c9 leave <== NOT EXECUTED 10d2e6: c3 ret <== NOT EXECUTED 0010d1b8 <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 10d1b8: 55 push %ebp <== NOT EXECUTED 10d1b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d1bb: 57 push %edi <== NOT EXECUTED 10d1bc: 56 push %esi <== NOT EXECUTED 10d1bd: 53 push %ebx <== NOT EXECUTED 10d1be: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d1c1: 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; 10d1c4: 8b 3d 98 ea 11 00 mov 0x11ea98,%edi <== NOT EXECUTED _ISR_Disable( level ); 10d1ca: 9c pushf <== NOT EXECUTED 10d1cb: fa cli <== NOT EXECUTED 10d1cc: 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 ) { 10d1cf: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 10d1d2: 85 c0 test %eax,%eax <== NOT EXECUTED 10d1d4: 75 72 jne 10d248 <_Watchdog_Insert+0x90> <== NOT EXECUTED _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 10d1d6: c7 46 08 01 00 00 00 movl $0x1,0x8(%esi) <== NOT EXECUTED _Watchdog_Sync_count++; 10d1dd: a1 60 eb 11 00 mov 0x11eb60,%eax <== NOT EXECUTED 10d1e2: 40 inc %eax <== NOT EXECUTED 10d1e3: a3 60 eb 11 00 mov %eax,0x11eb60 <== NOT EXECUTED restart: delta_interval = the_watchdog->initial; 10d1e8: 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 ; 10d1eb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10d1ee: 8b 08 mov (%eax),%ecx <== NOT EXECUTED ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10d1f0: 85 db test %ebx,%ebx <== NOT EXECUTED 10d1f2: 74 65 je 10d259 <_Watchdog_Insert+0xa1> <== NOT EXECUTED 10d1f4: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 10d1f6: 85 c0 test %eax,%eax <== NOT EXECUTED 10d1f8: 74 5f je 10d259 <_Watchdog_Insert+0xa1> <== NOT EXECUTED break; if ( delta_interval < after->delta_interval ) { 10d1fa: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED 10d1fd: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 10d1ff: 73 21 jae 10d222 <_Watchdog_Insert+0x6a> <== NOT EXECUTED 10d201: eb 51 jmp 10d254 <_Watchdog_Insert+0x9c> <== NOT EXECUTED 10d203: 90 nop <== NOT EXECUTED if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 10d204: a1 b8 ea 11 00 mov 0x11eab8,%eax <== NOT EXECUTED 10d209: 39 c7 cmp %eax,%edi <== NOT EXECUTED 10d20b: 72 6f jb 10d27c <_Watchdog_Insert+0xc4> <== NOT EXECUTED if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; break; } delta_interval -= after->delta_interval; 10d20d: 29 d3 sub %edx,%ebx <== NOT EXECUTED ); #ifdef __cplusplus } #endif 10d20f: 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 ) ) 10d211: 85 db test %ebx,%ebx <== NOT EXECUTED 10d213: 74 44 je 10d259 <_Watchdog_Insert+0xa1> <== NOT EXECUTED 10d215: 8b 11 mov (%ecx),%edx <== NOT EXECUTED 10d217: 85 d2 test %edx,%edx <== NOT EXECUTED 10d219: 74 3e je 10d259 <_Watchdog_Insert+0xa1> <== NOT EXECUTED break; if ( delta_interval < after->delta_interval ) { 10d21b: 8b 51 10 mov 0x10(%ecx),%edx <== NOT EXECUTED 10d21e: 39 da cmp %ebx,%edx <== NOT EXECUTED 10d220: 77 32 ja 10d254 <_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 ); 10d222: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10d225: 9d popf <== NOT EXECUTED 10d226: fa cli <== NOT EXECUTED if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 10d227: 83 7e 08 01 cmpl $0x1,0x8(%esi) <== NOT EXECUTED 10d22b: 74 d7 je 10d204 <_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; 10d22d: 89 3d b8 ea 11 00 mov %edi,0x11eab8 <== NOT EXECUTED _Watchdog_Sync_count--; 10d233: a1 60 eb 11 00 mov 0x11eb60,%eax <== NOT EXECUTED 10d238: 48 dec %eax <== NOT EXECUTED 10d239: a3 60 eb 11 00 mov %eax,0x11eb60 <== NOT EXECUTED _ISR_Enable( level ); 10d23e: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10d241: 9d popf <== NOT EXECUTED } 10d242: 58 pop %eax <== NOT EXECUTED 10d243: 5b pop %ebx <== NOT EXECUTED 10d244: 5e pop %esi <== NOT EXECUTED 10d245: 5f pop %edi <== NOT EXECUTED 10d246: c9 leave <== NOT EXECUTED 10d247: 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 ); 10d248: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10d24b: 9d popf <== NOT EXECUTED exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; _Watchdog_Sync_count--; _ISR_Enable( level ); } 10d24c: 58 pop %eax <== NOT EXECUTED 10d24d: 5b pop %ebx <== NOT EXECUTED 10d24e: 5e pop %esi <== NOT EXECUTED 10d24f: 5f pop %edi <== NOT EXECUTED 10d250: c9 leave <== NOT EXECUTED 10d251: c3 ret <== NOT EXECUTED 10d252: 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; 10d254: 29 da sub %ebx,%edx <== NOT EXECUTED 10d256: 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( 10d259: c7 46 08 02 00 00 00 movl $0x2,0x8(%esi) <== NOT EXECUTED } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 10d260: 89 5e 10 mov %ebx,0x10(%esi) <== NOT EXECUTED _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 10d263: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d266: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 10d269: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10d26b: 89 30 mov %esi,(%eax) <== NOT EXECUTED 10d26d: 89 16 mov %edx,(%esi) <== NOT EXECUTED 10d26f: 89 72 04 mov %esi,0x4(%edx) <== NOT EXECUTED the_watchdog->start_time = _Watchdog_Ticks_since_boot; 10d272: a1 64 eb 11 00 mov 0x11eb64,%eax <== NOT EXECUTED 10d277: 89 46 14 mov %eax,0x14(%esi) <== NOT EXECUTED 10d27a: eb b1 jmp 10d22d <_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; 10d27c: 89 3d b8 ea 11 00 mov %edi,0x11eab8 <== NOT EXECUTED 10d282: e9 61 ff ff ff jmp 10d1e8 <_Watchdog_Insert+0x30> <== NOT EXECUTED 0010d2e8 <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10d2e8: 55 push %ebp <== NOT EXECUTED 10d2e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d2eb: 56 push %esi <== NOT EXECUTED 10d2ec: 53 push %ebx <== NOT EXECUTED 10d2ed: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10d2f0: 9c pushf <== NOT EXECUTED 10d2f1: fa cli <== NOT EXECUTED 10d2f2: 5e pop %esi <== NOT EXECUTED previous_state = the_watchdog->state; 10d2f3: 8b 59 08 mov 0x8(%ecx),%ebx <== NOT EXECUTED switch ( previous_state ) { 10d2f6: 83 fb 01 cmp $0x1,%ebx <== NOT EXECUTED 10d2f9: 74 4d je 10d348 <_Watchdog_Remove+0x60> <== NOT EXECUTED 10d2fb: 73 13 jae 10d310 <_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; 10d2fd: a1 64 eb 11 00 mov 0x11eb64,%eax <== NOT EXECUTED 10d302: 89 41 18 mov %eax,0x18(%ecx) <== NOT EXECUTED _ISR_Enable( level ); 10d305: 56 push %esi <== NOT EXECUTED 10d306: 9d popf <== NOT EXECUTED return( previous_state ); } 10d307: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10d309: 5b pop %ebx <== NOT EXECUTED 10d30a: 5e pop %esi <== NOT EXECUTED 10d30b: c9 leave <== NOT EXECUTED 10d30c: c3 ret <== NOT EXECUTED 10d30d: 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 ) { 10d310: 83 fb 03 cmp $0x3,%ebx <== NOT EXECUTED 10d313: 77 e8 ja 10d2fd <_Watchdog_Remove+0x15> <== NOT EXECUTED break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10d315: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED ); #ifdef __cplusplus } #endif 10d31c: 8b 11 mov (%ecx),%edx <== NOT EXECUTED next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 10d31e: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10d320: 85 c0 test %eax,%eax <== NOT EXECUTED 10d322: 74 06 je 10d32a <_Watchdog_Remove+0x42> <== NOT EXECUTED next_watchdog->delta_interval += the_watchdog->delta_interval; 10d324: 8b 41 10 mov 0x10(%ecx),%eax <== NOT EXECUTED 10d327: 01 42 10 add %eax,0x10(%edx) <== NOT EXECUTED if ( _Watchdog_Sync_count ) 10d32a: a1 60 eb 11 00 mov 0x11eb60,%eax <== NOT EXECUTED 10d32f: 85 c0 test %eax,%eax <== NOT EXECUTED 10d331: 74 0a je 10d33d <_Watchdog_Remove+0x55> <== NOT EXECUTED _Watchdog_Sync_level = _ISR_Nest_level; 10d333: a1 98 ea 11 00 mov 0x11ea98,%eax <== NOT EXECUTED 10d338: a3 b8 ea 11 00 mov %eax,0x11eab8 <== NOT EXECUTED 10d33d: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d340: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED 10d343: 89 10 mov %edx,(%eax) <== NOT EXECUTED 10d345: eb b6 jmp 10d2fd <_Watchdog_Remove+0x15> <== NOT EXECUTED 10d347: 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; 10d348: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED 10d34f: eb ac jmp 10d2fd <_Watchdog_Remove+0x15> <== NOT EXECUTED 0010d354 <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10d354: 55 push %ebp <== NOT EXECUTED 10d355: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d357: 57 push %edi <== NOT EXECUTED 10d358: 56 push %esi <== NOT EXECUTED 10d359: 53 push %ebx <== NOT EXECUTED 10d35a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d35d: 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 ); 10d360: 9c pushf <== NOT EXECUTED 10d361: fa cli <== NOT EXECUTED 10d362: 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( 10d363: 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 10d365: 8d 47 04 lea 0x4(%edi),%eax <== NOT EXECUTED 10d368: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED if ( _Chain_Is_empty( header ) ) 10d36b: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10d36d: 74 11 je 10d380 <_Watchdog_Tickle+0x2c> <== NOT EXECUTED 10d36f: 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) { 10d371: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 10d374: 85 c0 test %eax,%eax <== NOT EXECUTED 10d376: 74 34 je 10d3ac <_Watchdog_Tickle+0x58> <== NOT EXECUTED the_watchdog->delta_interval--; 10d378: 48 dec %eax <== NOT EXECUTED 10d379: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED if ( the_watchdog->delta_interval != 0 ) 10d37c: 85 c0 test %eax,%eax <== NOT EXECUTED 10d37e: 74 2c je 10d3ac <_Watchdog_Tickle+0x58> <== NOT EXECUTED the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); 10d380: 56 push %esi <== NOT EXECUTED 10d381: 9d popf <== NOT EXECUTED } 10d382: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d385: 5b pop %ebx <== NOT EXECUTED 10d386: 5e pop %esi <== NOT EXECUTED 10d387: 5f pop %edi <== NOT EXECUTED 10d388: c9 leave <== NOT EXECUTED 10d389: c3 ret <== NOT EXECUTED _ISR_Enable( level ); switch( watchdog_state ) { case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10d38a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10d38d: ff 73 24 pushl 0x24(%ebx) <== NOT EXECUTED 10d390: ff 73 20 pushl 0x20(%ebx) <== NOT EXECUTED 10d393: ff 53 1c call *0x1c(%ebx) <== NOT EXECUTED 10d396: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10d399: 9c pushf <== NOT EXECUTED 10d39a: fa cli <== NOT EXECUTED 10d39b: 5e pop %esi <== NOT EXECUTED 10d39c: 8b 07 mov (%edi),%eax <== NOT EXECUTED the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10d39e: 39 45 f0 cmp %eax,-0x10(%ebp) <== NOT EXECUTED 10d3a1: 74 dd je 10d380 <_Watchdog_Tickle+0x2c> <== NOT EXECUTED 10d3a3: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10d3a5: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 10d3a8: 85 c0 test %eax,%eax <== NOT EXECUTED 10d3aa: 75 d4 jne 10d380 <_Watchdog_Tickle+0x2c> <== NOT EXECUTED if ( the_watchdog->delta_interval != 0 ) goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10d3ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d3af: 53 push %ebx <== NOT EXECUTED 10d3b0: e8 33 ff ff ff call 10d2e8 <_Watchdog_Remove> <== NOT EXECUTED _ISR_Enable( level ); 10d3b5: 56 push %esi <== NOT EXECUTED 10d3b6: 9d popf <== NOT EXECUTED switch( watchdog_state ) { 10d3b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d3ba: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10d3bd: 75 da jne 10d399 <_Watchdog_Tickle+0x45> <== NOT EXECUTED 10d3bf: eb c9 jmp 10d38a <_Watchdog_Tickle+0x36> <== NOT EXECUTED 0010d3dc <_Workspace_Allocate>: * _Workspace_Allocate */ void *_Workspace_Allocate( size_t size ) { 10d3dc: 55 push %ebp <== NOT EXECUTED 10d3dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d3df: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Heap_Allocate( &_Workspace_Area, size ); 10d3e2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d3e5: 68 20 ea 11 00 push $0x11ea20 <== NOT EXECUTED 10d3ea: e8 71 1e 00 00 call 10f260 <_Heap_Allocate> <== NOT EXECUTED } 10d3ef: c9 leave <== NOT EXECUTED 10d3f0: c3 ret <== NOT EXECUTED 0010d3f4 <_Workspace_Allocate_or_fatal_error>: * _Workspace_Allocate_or_fatal_error */ void *_Workspace_Allocate_or_fatal_error( size_t size ) { 10d3f4: 55 push %ebp <== NOT EXECUTED 10d3f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d3f7: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED */ void *_Workspace_Allocate( size_t size ) { return _Heap_Allocate( &_Workspace_Area, size ); 10d3fa: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d3fd: 68 20 ea 11 00 push $0x11ea20 <== NOT EXECUTED 10d402: e8 59 1e 00 00 call 10f260 <_Heap_Allocate> <== NOT EXECUTED { void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) 10d407: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d40a: 85 c0 test %eax,%eax <== NOT EXECUTED 10d40c: 74 02 je 10d410 <_Workspace_Allocate_or_fatal_error+0x1c> <== NOT EXECUTED TRUE, INTERNAL_ERROR_WORKSPACE_ALLOCATION ); return memory; } 10d40e: c9 leave <== NOT EXECUTED 10d40f: c3 ret <== NOT EXECUTED void *memory; memory = _Workspace_Allocate( size ); if ( memory == NULL ) _Internal_error_Occurred( 10d410: 50 push %eax <== NOT EXECUTED 10d411: 6a 04 push $0x4 <== NOT EXECUTED 10d413: 6a 01 push $0x1 <== NOT EXECUTED 10d415: 6a 00 push $0x0 <== NOT EXECUTED 10d417: e8 c0 e0 ff ff call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED 0010d3c4 <_Workspace_Free>: * _Workspace_Free */ bool _Workspace_Free( void *block ) { 10d3c4: 55 push %ebp <== NOT EXECUTED 10d3c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d3c7: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return _Heap_Free( &_Workspace_Area, block ); 10d3ca: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d3cd: 68 20 ea 11 00 push $0x11ea20 <== NOT EXECUTED 10d3d2: e8 1d 1f 00 00 call 10f2f4 <_Heap_Free> <== NOT EXECUTED } 10d3d7: c9 leave <== NOT EXECUTED 10d3d8: c3 ret <== NOT EXECUTED 0010d41c <_Workspace_Handler_initialization>: */ void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 10d41c: 55 push %ebp <== NOT EXECUTED 10d41d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d41f: 57 push %edi <== NOT EXECUTED 10d420: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d423: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) 10d426: 85 d2 test %edx,%edx <== NOT EXECUTED 10d428: 74 2e je 10d458 <_Workspace_Handler_initialization+0x3c> <== NOT EXECUTED 10d42a: f6 c2 03 test $0x3,%dl <== NOT EXECUTED 10d42d: 75 29 jne 10d458 <_Workspace_Handler_initialization+0x3c> <== NOT EXECUTED INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _Configuration_Table->do_zero_of_workspace ) 10d42f: a1 94 ea 11 00 mov 0x11ea94,%eax <== NOT EXECUTED 10d434: 80 78 28 00 cmpb $0x0,0x28(%eax) <== NOT EXECUTED 10d438: 75 2a jne 10d464 <_Workspace_Handler_initialization+0x48> <== NOT EXECUTED memset( starting_address, 0, size ); memory_available = _Heap_Initialize( 10d43a: 6a 04 push $0x4 <== NOT EXECUTED 10d43c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d43f: 52 push %edx <== NOT EXECUTED 10d440: 68 20 ea 11 00 push $0x11ea20 <== NOT EXECUTED 10d445: e8 aa de ff ff call 10b2f4 <_Heap_Initialize> <== NOT EXECUTED starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 10d44a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d44d: 85 c0 test %eax,%eax <== NOT EXECUTED 10d44f: 74 1e je 10d46f <_Workspace_Handler_initialization+0x53> <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } 10d451: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 10d454: c9 leave <== NOT EXECUTED 10d455: c3 ret <== NOT EXECUTED 10d456: 66 90 xchg %ax,%ax <== NOT EXECUTED ) { uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) _Internal_error_Occurred( 10d458: 51 push %ecx <== NOT EXECUTED 10d459: 6a 02 push $0x2 <== NOT EXECUTED 10d45b: 6a 01 push $0x1 <== NOT EXECUTED 10d45d: 6a 00 push $0x0 <== NOT EXECUTED 10d45f: e8 78 e0 ff ff call 10b4dc <_Internal_error_Occurred> <== NOT EXECUTED TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _Configuration_Table->do_zero_of_workspace ) memset( starting_address, 0, size ); 10d464: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d466: 89 d7 mov %edx,%edi <== NOT EXECUTED 10d468: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10d46b: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 10d46d: eb cb jmp 10d43a <_Workspace_Handler_initialization+0x1e> <== NOT EXECUTED size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) _Internal_error_Occurred( 10d46f: 52 push %edx <== NOT EXECUTED 10d470: 6a 03 push $0x3 <== NOT EXECUTED 10d472: 6a 01 push $0x1 <== NOT EXECUTED 10d474: 6a 00 push $0x0 <== NOT EXECUTED 10d476: e8 61 e0 ff ff call 10b4dc <_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 97 83 11 00 mov $0x118397,%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 a4 83 11 00 push $0x1183a4 <== 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 a4 3b 00 00 call 10aa40 <== NOT EXECUTED int line, const char *func, const char *failedexpr ) { printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n", 106e9c: ba 06 85 11 00 mov $0x118506,%edx <== NOT EXECUTED 106ea1: 89 d0 mov %edx,%eax <== NOT EXECUTED 106ea3: eb d5 jmp 106e7a <__assert_func+0x12> <== NOT EXECUTED 0011fc18 <__env_lock>: 11fc18: 55 push %ebp <== NOT EXECUTED 11fc19: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fc1b: c9 leave <== NOT EXECUTED 11fc1c: c3 ret <== NOT EXECUTED 0011fc20 <__env_unlock>: 11fc20: 55 push %ebp <== NOT EXECUTED 11fc21: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11fc23: c9 leave <== NOT EXECUTED 11fc24: c3 ret <== NOT EXECUTED 00120f54 <__kill>: #endif #endif int __kill( pid_t pid, int sig ) { 120f54: 55 push %ebp <== NOT EXECUTED 120f55: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 120f57: 31 c0 xor %eax,%eax <== NOT EXECUTED 120f59: c9 leave <== NOT EXECUTED 120f5a: c3 ret <== NOT EXECUTED 001164a0 <_calloc_r>: void *_calloc_r( struct _reent *ignored, size_t elements, size_t size ) { 1164a0: 55 push %ebp <== NOT EXECUTED 1164a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1164a3: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return calloc( elements, size ); 1164a6: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1164a9: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1164ac: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 1164af: c9 leave <== NOT EXECUTED struct _reent *ignored, size_t elements, size_t size ) { return calloc( elements, size ); 1164b0: e9 9f 7f ff ff jmp 10e454 <== NOT EXECUTED 0010e518 <_close_r>: int _close_r( struct _reent *ptr, int fd ) { 10e518: 55 push %ebp <== NOT EXECUTED 10e519: 89 e5 mov %esp,%ebp <== NOT EXECUTED return close( fd ); 10e51b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e51e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10e521: c9 leave <== NOT EXECUTED int _close_r( struct _reent *ptr, int fd ) { return close( fd ); 10e522: e9 69 ff ff ff jmp 10e490 <== NOT EXECUTED 00116704 <_exit>: /* * If the toolset uses init/fini sections, then we need to * run the global destructors now. */ #if defined(__USE_INIT_FINI__) _fini(); 116704: 55 push %ebp <== NOT EXECUTED 116705: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116707: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11670a: e8 5e 07 00 00 call 116e6d <_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(); 11670f: e8 84 ff ff ff call 116698 <== NOT EXECUTED rtems_shutdown_executive(status); 116714: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116717: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11671a: e8 f9 00 00 00 call 116818 <== NOT EXECUTED 11671f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116722: eb fe jmp 116722 <_exit+0x1e> <== NOT EXECUTED 0012f41c <_fcntl_r>: struct _reent *ptr, int fd, int cmd, int arg ) { 12f41c: 55 push %ebp <== NOT EXECUTED 12f41d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f41f: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 12f422: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return fcntl( fd, cmd, arg ); 12f425: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 12f428: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 12f42b: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 12f42e: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 12f431: c9 leave <== NOT EXECUTED int fd, int cmd, int arg ) { return fcntl( fd, cmd, arg ); 12f432: e9 11 fe ff ff jmp 12f248 <== NOT EXECUTED 001164b8 <_free_r>: void _free_r( struct _reent *ignored, void *ptr ) { 1164b8: 55 push %ebp <== NOT EXECUTED 1164b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED free( ptr ); 1164bb: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1164be: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 1164c1: c9 leave <== NOT EXECUTED void _free_r( struct _reent *ignored, void *ptr ) { free( ptr ); 1164c2: e9 d9 0b ff ff jmp 1070a0 <== NOT EXECUTED 00116564 <_fstat_r>: int _fstat_r( struct _reent *ptr, int fd, struct stat *buf ) { 116564: 55 push %ebp <== NOT EXECUTED 116565: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116567: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return fstat( fd, buf ); 11656a: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11656d: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 116570: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 116573: c9 leave <== NOT EXECUTED struct _reent *ptr, int fd, struct stat *buf ) { return fstat( fd, buf ); 116574: e9 4f ff ff ff jmp 1164c8 <== NOT EXECUTED 00120e1c <_getpid_r>: #include pid_t _getpid_r( struct _reent *ptr ) { 120e1c: 55 push %ebp <== NOT EXECUTED 120e1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED return getpid(); } 120e1f: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 120e24: c9 leave <== NOT EXECUTED 120e25: c3 ret <== NOT EXECUTED 0010e640 <_gettimeofday>: int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { 10e640: 55 push %ebp <== NOT EXECUTED 10e641: 89 e5 mov %esp,%ebp <== NOT EXECUTED return gettimeofday( tp, tzp ); } 10e643: c9 leave <== NOT EXECUTED int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp ); 10e644: e9 a3 ff ff ff jmp 10e5ec <== NOT EXECUTED 0010e64c <_gettimeofday_r>: int _gettimeofday_r( struct _reent *ignored_reentrancy_stuff, struct timeval *tp, struct timezone *tzp ) { 10e64c: 55 push %ebp <== NOT EXECUTED 10e64d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e64f: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return gettimeofday( tp, tzp ); 10e652: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10e655: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 10e658: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10e65b: c9 leave <== NOT EXECUTED struct _reent *ignored_reentrancy_stuff, struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp ); 10e65c: e9 8b ff ff ff jmp 10e5ec <== NOT EXECUTED 00120f4c <_kill_r>: #if defined(RTEMS_NEWLIB) #include int _kill_r( struct _reent *ptr, pid_t pid, int sig ) { 120f4c: 55 push %ebp <== NOT EXECUTED 120f4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 120f4f: 31 c0 xor %eax,%eax <== NOT EXECUTED 120f51: c9 leave <== NOT EXECUTED 120f52: c3 ret <== NOT EXECUTED 001249f4 <_link_r>: int _link_r( struct _reent *ptr, const char *existing, const char *new ) { 1249f4: 55 push %ebp <== NOT EXECUTED 1249f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1249f7: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return link( existing, new ); 1249fa: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1249fd: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 124a00: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 124a03: c9 leave <== NOT EXECUTED struct _reent *ptr, const char *existing, const char *new ) { return link( existing, new ); 124a04: e9 03 fe ff ff jmp 12480c <== NOT EXECUTED 0011666c <_lseek_r>: struct _reent *ptr, int fd, off_t offset, int whence ) { 11666c: 55 push %ebp <== NOT EXECUTED 11666d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11666f: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 116672: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return lseek( fd, offset, whence ); 116675: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 116678: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 11667b: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 11667e: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 116681: c9 leave <== NOT EXECUTED int fd, off_t offset, int whence ) { return lseek( fd, offset, whence ); 116682: e9 29 ff ff ff jmp 1165b0 <== NOT EXECUTED 00124ba0 <_lstat_r>: int _STAT_R_NAME( struct _reent *ptr, const char *path, struct stat *buf ) { 124ba0: 55 push %ebp <== NOT EXECUTED 124ba1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124ba3: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return _STAT_NAME( path, buf ); 124ba6: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 124ba9: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 124bac: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 124baf: c9 leave <== NOT EXECUTED struct _reent *ptr, const char *path, struct stat *buf ) { return _STAT_NAME( path, buf ); 124bb0: e9 2f ff ff ff jmp 124ae4 <== NOT EXECUTED 00116688 <_malloc_r>: void *_malloc_r( struct _reent *ignored, size_t size ) { 116688: 55 push %ebp <== NOT EXECUTED 116689: 89 e5 mov %esp,%ebp <== NOT EXECUTED return malloc( size ); 11668b: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 11668e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 116691: c9 leave <== NOT EXECUTED void *_malloc_r( struct _reent *ignored, size_t size ) { return malloc( size ); 116692: e9 21 0c 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 001167c8 <_read_r>: struct _reent *ptr, int fd, void *buf, size_t nbytes ) { 1167c8: 55 push %ebp <== NOT EXECUTED 1167c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1167cb: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1167ce: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return read( fd, buf, nbytes ); 1167d1: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1167d4: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 1167d7: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 1167da: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 1167dd: c9 leave <== NOT EXECUTED int fd, void *buf, size_t nbytes ) { return read( fd, buf, nbytes ); 1167de: e9 41 ff ff ff jmp 116724 <== NOT EXECUTED 001167e4 <_realloc_r>: void *_realloc_r( struct _reent *ignored, void *ptr, size_t size ) { 1167e4: 55 push %ebp <== NOT EXECUTED 1167e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1167e7: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return realloc( ptr, size ); 1167ea: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1167ed: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1167f0: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 1167f3: c9 leave <== NOT EXECUTED struct _reent *ignored, void *ptr, size_t size ) { return realloc( ptr, size ); 1167f4: e9 4f 00 00 00 jmp 116848 <== NOT EXECUTED 0013eeec <_rename_r>: int _rename_r( struct _reent *ptr, const char *old, const char *new ) { 13eeec: 55 push %ebp <== NOT EXECUTED 13eeed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 13eeef: 53 push %ebx <== NOT EXECUTED 13eef0: 83 ec 5c sub $0x5c,%esp <== NOT EXECUTED 13eef3: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED struct stat sb; int s; s = stat( old, &sb); 13eef6: 8d 45 b0 lea -0x50(%ebp),%eax <== NOT EXECUTED 13eef9: 50 push %eax <== NOT EXECUTED 13eefa: 53 push %ebx <== NOT EXECUTED 13eefb: e8 50 da fc ff call 10c950 <== NOT EXECUTED if ( s < 0 ) 13ef00: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 13ef03: 85 c0 test %eax,%eax <== NOT EXECUTED 13ef05: 78 2e js 13ef35 <_rename_r+0x49> <== NOT EXECUTED return s; s = link( old, new ); 13ef07: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 13ef0a: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 13ef0d: 53 push %ebx <== NOT EXECUTED 13ef0e: e8 f9 58 fe ff call 12480c <== NOT EXECUTED if ( s < 0 ) 13ef13: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 13ef16: 85 c0 test %eax,%eax <== NOT EXECUTED 13ef18: 78 1b js 13ef35 <_rename_r+0x49> <== NOT EXECUTED return s; return S_ISDIR(sb.st_mode) ? rmdir( old ) : unlink( old ); 13ef1a: 8b 45 bc mov -0x44(%ebp),%eax <== NOT EXECUTED 13ef1d: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 13ef22: 3d 00 40 00 00 cmp $0x4000,%eax <== NOT EXECUTED 13ef27: 74 13 je 13ef3c <_rename_r+0x50> <== NOT EXECUTED 13ef29: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 13ef2c: 53 push %ebx <== NOT EXECUTED 13ef2d: e8 b2 f7 fc ff call 10e6e4 <== NOT EXECUTED 13ef32: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 13ef35: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 13ef38: c9 leave <== NOT EXECUTED 13ef39: c3 ret <== NOT EXECUTED 13ef3a: 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 ); 13ef3c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 13ef3f: 53 push %ebx <== NOT EXECUTED 13ef40: e8 37 62 fe ff call 12517c <== NOT EXECUTED 13ef45: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 13ef48: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 13ef4b: c9 leave <== NOT EXECUTED 13ef4c: 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 001167fc <_write_r>: struct _reent *ptr, int fd, const void *buf, size_t nbytes ) { 1167fc: 55 push %ebp <== NOT EXECUTED 1167fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1167ff: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 116802: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return write( fd, buf, nbytes ); 116805: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 116808: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 11680b: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 11680e: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 116811: c9 leave <== NOT EXECUTED int fd, const void *buf, size_t nbytes ) { return write( fd, buf, nbytes ); 116812: e9 1d 01 00 00 jmp 116934 <== NOT EXECUTED 00123100 : int access( const char *path, int amode ) { 123100: 55 push %ebp <== NOT EXECUTED 123101: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123103: 83 ec 60 sub $0x60,%esp <== NOT EXECUTED struct stat statbuf; if ( stat(path, &statbuf) ) 123106: 8d 45 b4 lea -0x4c(%ebp),%eax <== NOT EXECUTED 123109: 50 push %eax <== NOT EXECUTED 12310a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12310d: e8 3e 98 fe ff call 10c950 <== NOT EXECUTED 123112: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123115: 85 c0 test %eax,%eax <== NOT EXECUTED 123117: 75 1f jne 123138 <== NOT EXECUTED return -1; if ( amode & R_OK ) { 123119: f6 45 0c 04 testb $0x4,0xc(%ebp) <== NOT EXECUTED 12311d: 75 11 jne 123130 <== NOT EXECUTED if (!( statbuf.st_mode & S_IREAD )) return -1; } if ( amode & W_OK ) { 12311f: f6 45 0c 02 testb $0x2,0xc(%ebp) <== NOT EXECUTED 123123: 75 27 jne 12314c <== NOT EXECUTED if ( !( statbuf.st_mode & S_IWRITE ) ) return -1; } if ( amode & X_OK ) { 123125: f6 45 0c 01 testb $0x1,0xc(%ebp) <== NOT EXECUTED 123129: 75 15 jne 123140 <== NOT EXECUTED if ( !( statbuf.st_mode & S_IEXEC ) ) 12312b: 31 c0 xor %eax,%eax <== NOT EXECUTED return -1; } return 0; } 12312d: c9 leave <== NOT EXECUTED 12312e: c3 ret <== NOT EXECUTED 12312f: 90 nop <== NOT EXECUTED if ( stat(path, &statbuf) ) return -1; if ( amode & R_OK ) { if (!( statbuf.st_mode & S_IREAD )) 123130: f6 45 c1 01 testb $0x1,-0x3f(%ebp) <== NOT EXECUTED 123134: 75 e9 jne 12311f <== NOT EXECUTED 123136: 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 ) ) 123138: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED return -1; } return 0; } 12313d: c9 leave <== NOT EXECUTED 12313e: c3 ret <== NOT EXECUTED 12313f: 90 nop <== NOT EXECUTED if ( !( statbuf.st_mode & S_IWRITE ) ) return -1; } if ( amode & X_OK ) { if ( !( statbuf.st_mode & S_IEXEC ) ) 123140: f6 45 c0 40 testb $0x40,-0x40(%ebp) <== NOT EXECUTED 123144: 74 f2 je 123138 <== NOT EXECUTED 123146: 31 c0 xor %eax,%eax <== NOT EXECUTED 123148: eb e3 jmp 12312d <== NOT EXECUTED 12314a: 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 ) ) 12314c: 80 7d c0 00 cmpb $0x0,-0x40(%ebp) <== NOT EXECUTED 123150: 78 d3 js 123125 <== NOT EXECUTED 123152: eb e4 jmp 123138 <== NOT EXECUTED 0010e454 : ) { register char *cptr; int length; MSBUMP(calloc_calls, 1); 10e454: 55 push %ebp <== NOT EXECUTED 10e455: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e457: 57 push %edi <== NOT EXECUTED 10e458: 53 push %ebx <== NOT EXECUTED 10e459: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 10e45c: ff 05 14 e9 11 00 incl 0x11e914 <== NOT EXECUTED length = nelem * elsize; 10e462: 0f af 5d 08 imul 0x8(%ebp),%ebx <== NOT EXECUTED cptr = malloc( length ); 10e466: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e469: 53 push %ebx <== NOT EXECUTED 10e46a: e8 49 8e ff ff call 1072b8 <== NOT EXECUTED 10e46f: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( cptr ) 10e471: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e474: 85 c0 test %eax,%eax <== NOT EXECUTED 10e476: 74 08 je 10e480 <== NOT EXECUTED memset( cptr, '\0', length ); 10e478: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e47a: 89 d7 mov %edx,%edi <== NOT EXECUTED 10e47c: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 10e47e: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED MSBUMP(malloc_calls, -1); /* subtract off the malloc */ 10e480: ff 0d 04 e9 11 00 decl 0x11e904 <== NOT EXECUTED return cptr; } 10e486: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e488: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e48b: 5b pop %ebx <== NOT EXECUTED 10e48c: 5f pop %edi <== NOT EXECUTED 10e48d: c9 leave <== NOT EXECUTED 10e48e: c3 ret <== NOT EXECUTED 00123314 : #include int chdir( const char *pathname ) { 123314: 55 push %ebp <== NOT EXECUTED 123315: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123317: 57 push %edi <== NOT EXECUTED 123318: 56 push %esi <== NOT EXECUTED 123319: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED /* * Get the node where we wish to go. */ result = rtems_filesystem_evaluate_path( 12331c: 6a 01 push $0x1 <== NOT EXECUTED 12331e: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 123321: 56 push %esi <== NOT EXECUTED 123322: 6a 01 push $0x1 <== NOT EXECUTED 123324: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 123327: e8 00 7f fe ff call 10b22c <== NOT EXECUTED pathname, RTEMS_LIBIO_PERMS_SEARCH, &loc, true ); if ( result != 0 ) 12332c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12332f: 85 c0 test %eax,%eax <== NOT EXECUTED 123331: 75 69 jne 12339c <== NOT EXECUTED /* * Verify you can change directory into this node. */ if ( !loc.ops->node_type_h ) { 123333: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 123336: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 123339: 85 c0 test %eax,%eax <== NOT EXECUTED 12333b: 74 43 je 123380 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 12333d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123340: 56 push %esi <== NOT EXECUTED 123341: ff d0 call *%eax <== NOT EXECUTED 123343: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123346: 48 dec %eax <== NOT EXECUTED 123347: 75 5f jne 1233a8 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTDIR ); } rtems_filesystem_freenode( &rtems_filesystem_current ); 123349: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED 12334e: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 123351: 85 d2 test %edx,%edx <== NOT EXECUTED 123353: 74 18 je 12336d <== NOT EXECUTED 123355: 8b 52 1c mov 0x1c(%edx),%edx <== NOT EXECUTED 123358: 85 d2 test %edx,%edx <== NOT EXECUTED 12335a: 74 11 je 12336d <== NOT EXECUTED 12335c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12335f: 83 c0 04 add $0x4,%eax <== NOT EXECUTED 123362: 50 push %eax <== NOT EXECUTED 123363: ff d2 call *%edx <== NOT EXECUTED 123365: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123368: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED rtems_filesystem_current = loc; 12336d: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 123370: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 123375: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 123377: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 123379: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12337c: 5e pop %esi <== NOT EXECUTED 12337d: 5f pop %edi <== NOT EXECUTED 12337e: c9 leave <== NOT EXECUTED 12337f: c3 ret <== NOT EXECUTED /* * Verify you can change directory into this node. */ if ( !loc.ops->node_type_h ) { rtems_filesystem_freenode( &loc ); 123380: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 123383: 85 c0 test %eax,%eax <== NOT EXECUTED 123385: 74 09 je 123390 <== NOT EXECUTED 123387: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12338a: 56 push %esi <== NOT EXECUTED 12338b: ff d0 call *%eax <== NOT EXECUTED 12338d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 123390: e8 4b da 00 00 call 130de0 <__errno> <== NOT EXECUTED 123395: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12339b: 90 nop <== NOT EXECUTED 12339c: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED rtems_filesystem_freenode( &rtems_filesystem_current ); rtems_filesystem_current = loc; return 0; } 1233a1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1233a4: 5e pop %esi <== NOT EXECUTED 1233a5: 5f pop %edi <== NOT EXECUTED 1233a6: c9 leave <== NOT EXECUTED 1233a7: 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 ); 1233a8: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1233ab: 85 c0 test %eax,%eax <== NOT EXECUTED 1233ad: 74 10 je 1233bf <== NOT EXECUTED 1233af: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1233b2: 85 c0 test %eax,%eax <== NOT EXECUTED 1233b4: 74 09 je 1233bf <== NOT EXECUTED 1233b6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1233b9: 56 push %esi <== NOT EXECUTED 1233ba: ff d0 call *%eax <== NOT EXECUTED 1233bc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); 1233bf: e8 1c da 00 00 call 130de0 <__errno> <== NOT EXECUTED 1233c4: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 1233ca: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1233cf: eb a8 jmp 123379 <== 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 25 5d 02 00 call 130de0 <__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 f2 5c 02 00 call 130de0 <__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 001233d4 : int chown( const char *path, uid_t owner, gid_t group ) { 1233d4: 55 push %ebp <== NOT EXECUTED 1233d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1233d7: 57 push %edi <== NOT EXECUTED 1233d8: 56 push %esi <== NOT EXECUTED 1233d9: 53 push %ebx <== NOT EXECUTED 1233da: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1233dd: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 1233e0: 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 ) ) 1233e3: 6a 01 push $0x1 <== NOT EXECUTED 1233e5: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 1233e8: 56 push %esi <== NOT EXECUTED 1233e9: 6a 00 push $0x0 <== NOT EXECUTED 1233eb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1233ee: e8 39 7e fe ff call 10b22c <== NOT EXECUTED 1233f3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1233f6: 85 c0 test %eax,%eax <== NOT EXECUTED 1233f8: 75 5a jne 123454 <== NOT EXECUTED return -1; if ( !loc.ops->chown_h ) { 1233fa: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1233fd: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED 123400: 85 d2 test %edx,%edx <== NOT EXECUTED 123402: 74 32 je 123436 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->chown_h)( &loc, owner, group ); 123404: 50 push %eax <== NOT EXECUTED 123405: 0f b7 c3 movzwl %bx,%eax <== NOT EXECUTED 123408: 50 push %eax <== NOT EXECUTED 123409: 0f b7 c7 movzwl %di,%eax <== NOT EXECUTED 12340c: 50 push %eax <== NOT EXECUTED 12340d: 56 push %esi <== NOT EXECUTED 12340e: ff d2 call *%edx <== NOT EXECUTED 123410: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 123412: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 123415: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123418: 85 c0 test %eax,%eax <== NOT EXECUTED 12341a: 74 10 je 12342c <== NOT EXECUTED 12341c: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12341f: 85 c0 test %eax,%eax <== NOT EXECUTED 123421: 74 09 je 12342c <== NOT EXECUTED 123423: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123426: 56 push %esi <== NOT EXECUTED 123427: ff d0 call *%eax <== NOT EXECUTED 123429: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 12342c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12342e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 123431: 5b pop %ebx <== NOT EXECUTED 123432: 5e pop %esi <== NOT EXECUTED 123433: 5f pop %edi <== NOT EXECUTED 123434: c9 leave <== NOT EXECUTED 123435: c3 ret <== NOT EXECUTED if ( rtems_filesystem_evaluate_path( path, 0x00, &loc, true ) ) return -1; if ( !loc.ops->chown_h ) { rtems_filesystem_freenode( &loc ); 123436: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 123439: 85 c0 test %eax,%eax <== NOT EXECUTED 12343b: 74 09 je 123446 <== NOT EXECUTED 12343d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123440: 56 push %esi <== NOT EXECUTED 123441: ff d0 call *%eax <== NOT EXECUTED 123443: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 123446: e8 95 d9 00 00 call 130de0 <__errno> <== NOT EXECUTED 12344b: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 123451: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 123454: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED result = (*loc.ops->chown_h)( &loc, owner, group ); rtems_filesystem_freenode( &loc ); return result; } 123459: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12345b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12345e: 5b pop %ebx <== NOT EXECUTED 12345f: 5e pop %esi <== NOT EXECUTED 123460: 5f pop %edi <== NOT EXECUTED 123461: c9 leave <== NOT EXECUTED 123462: c3 ret <== NOT EXECUTED 00123464 : #include int chroot( const char *pathname ) { 123464: 55 push %ebp <== NOT EXECUTED 123465: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123467: 57 push %edi <== NOT EXECUTED 123468: 56 push %esi <== NOT EXECUTED 123469: 53 push %ebx <== NOT EXECUTED 12346a: 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) { 12346d: 81 3d ec ae 14 00 40 cmpl $0x161640,0x14aeec <== NOT EXECUTED 123474: 16 16 00 <== NOT EXECUTED 123477: 74 63 je 1234dc <== 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); 123479: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12347c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12347f: e8 90 fe ff ff call 123314 <== NOT EXECUTED if (result) { 123484: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123487: 85 c0 test %eax,%eax <== NOT EXECUTED 123489: 75 75 jne 123500 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( errno ); } /* clone the new root location */ if (rtems_filesystem_evaluate_path(".", 0, &loc, 0)) { 12348b: 6a 00 push $0x0 <== NOT EXECUTED 12348d: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 123490: 56 push %esi <== NOT EXECUTED 123491: 6a 00 push $0x0 <== NOT EXECUTED 123493: 68 10 18 14 00 push $0x141810 <== NOT EXECUTED 123498: e8 8f 7d fe ff call 10b22c <== NOT EXECUTED 12349d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1234a0: 85 c0 test %eax,%eax <== NOT EXECUTED 1234a2: 75 5c jne 123500 <== 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); 1234a4: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED 1234a9: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 1234ac: 85 d2 test %edx,%edx <== NOT EXECUTED 1234ae: 74 18 je 1234c8 <== NOT EXECUTED 1234b0: 8b 52 1c mov 0x1c(%edx),%edx <== NOT EXECUTED 1234b3: 85 d2 test %edx,%edx <== NOT EXECUTED 1234b5: 74 11 je 1234c8 <== NOT EXECUTED 1234b7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1234ba: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 1234bd: 50 push %eax <== NOT EXECUTED 1234be: ff d2 call *%edx <== NOT EXECUTED 1234c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1234c3: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED rtems_filesystem_root = loc; 1234c8: 8d 78 14 lea 0x14(%eax),%edi <== NOT EXECUTED 1234cb: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1234d0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1234d2: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 1234d4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1234d7: 5b pop %ebx <== NOT EXECUTED 1234d8: 5e pop %esi <== NOT EXECUTED 1234d9: 5f pop %edi <== NOT EXECUTED 1234da: c9 leave <== NOT EXECUTED 1234db: 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*/ 1234dc: e8 fb 19 00 00 call 124edc <== NOT EXECUTED if (rtems_current_user_env == &rtems_global_user_env) /* not ok */ 1234e1: 81 3d ec ae 14 00 40 cmpl $0x161640,0x14aeec <== NOT EXECUTED 1234e8: 16 16 00 <== NOT EXECUTED 1234eb: 75 8c jne 123479 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1234ed: e8 ee d8 00 00 call 130de0 <__errno> <== NOT EXECUTED 1234f2: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1234f8: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1234fd: eb d5 jmp 1234d4 <== NOT EXECUTED 1234ff: 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 ); 123500: e8 db d8 00 00 call 130de0 <__errno> <== NOT EXECUTED 123505: 89 c3 mov %eax,%ebx <== NOT EXECUTED 123507: e8 d4 d8 00 00 call 130de0 <__errno> <== NOT EXECUTED 12350c: 8b 00 mov (%eax),%eax <== NOT EXECUTED 12350e: 89 03 mov %eax,(%ebx) <== NOT EXECUTED 123510: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 123515: eb bd jmp 1234d4 <== NOT EXECUTED 0010e490 : #include int close( int fd ) { 10e490: 55 push %ebp <== NOT EXECUTED 10e491: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e493: 56 push %esi <== NOT EXECUTED 10e494: 53 push %ebx <== NOT EXECUTED 10e495: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED rtems_libio_t *iop; rtems_status_code rc; rtems_libio_check_fd(fd); 10e498: 3b 15 e0 a3 11 00 cmp 0x11a3e0,%edx <== NOT EXECUTED 10e49e: 73 64 jae 10e504 <== NOT EXECUTED iop = rtems_libio_iop(fd); 10e4a0: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10e4a3: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 10e4a6: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 10e4ad: 03 1d 70 e8 11 00 add 0x11e870,%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 10e4b3: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 10e4b7: 74 4b je 10e504 <== NOT EXECUTED rc = RTEMS_SUCCESSFUL; if ( iop->handlers->close_h ) 10e4b9: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10e4bc: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED 10e4bf: 85 c0 test %eax,%eax <== NOT EXECUTED 10e4c1: 74 3d je 10e500 <== NOT EXECUTED rc = (*iop->handlers->close_h)( iop ); 10e4c3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e4c6: 53 push %ebx <== NOT EXECUTED 10e4c7: ff d0 call *%eax <== NOT EXECUTED 10e4c9: 89 c6 mov %eax,%esi <== NOT EXECUTED 10e4cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &iop->pathinfo ); 10e4ce: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 10e4d1: 85 c0 test %eax,%eax <== NOT EXECUTED 10e4d3: 74 13 je 10e4e8 <== NOT EXECUTED 10e4d5: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 10e4d8: 85 d2 test %edx,%edx <== NOT EXECUTED 10e4da: 74 0c je 10e4e8 <== NOT EXECUTED 10e4dc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e4df: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10e4e2: 50 push %eax <== NOT EXECUTED 10e4e3: ff d2 call *%edx <== NOT EXECUTED 10e4e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_libio_free( iop ); 10e4e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e4eb: 53 push %ebx <== NOT EXECUTED 10e4ec: e8 7b 02 00 00 call 10e76c <== NOT EXECUTED 10e4f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return rc; } 10e4f4: 89 f0 mov %esi,%eax <== NOT EXECUTED 10e4f6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e4f9: 5b pop %ebx <== NOT EXECUTED 10e4fa: 5e pop %esi <== NOT EXECUTED 10e4fb: c9 leave <== NOT EXECUTED 10e4fc: c3 ret <== NOT EXECUTED 10e4fd: 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 ) 10e500: 31 f6 xor %esi,%esi <== NOT EXECUTED 10e502: eb ca jmp 10e4ce <== 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); 10e504: e8 af 1c 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10e509: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10e50f: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 10e514: eb de jmp 10e4f4 <== NOT EXECUTED 0012f0b8 : * close a directory. */ int closedir( DIR *dirp ) { 12f0b8: 55 push %ebp <== NOT EXECUTED 12f0b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f0bb: 56 push %esi <== NOT EXECUTED 12f0bc: 53 push %ebx <== NOT EXECUTED 12f0bd: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED int fd; if ( !dirp ) 12f0c0: 85 f6 test %esi,%esi <== NOT EXECUTED 12f0c2: 74 33 je 12f0f7 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); fd = dirp->dd_fd; 12f0c4: 8b 1e mov (%esi),%ebx <== NOT EXECUTED dirp->dd_fd = -1; 12f0c6: c7 06 ff ff ff ff movl $0xffffffff,(%esi) <== NOT EXECUTED dirp->dd_loc = 0; 12f0cc: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) <== NOT EXECUTED (void)free((void *)dirp->dd_buf); 12f0d3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12f0d6: ff 76 0c pushl 0xc(%esi) <== NOT EXECUTED 12f0d9: e8 92 c2 fd ff call 10b370 <== NOT EXECUTED (void)free((void *)dirp); 12f0de: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 12f0e1: e8 8a c2 fd ff call 10b370 <== NOT EXECUTED return(close(fd)); 12f0e6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12f0e9: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 12f0ec: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12f0ef: 5b pop %ebx <== NOT EXECUTED 12f0f0: 5e pop %esi <== NOT EXECUTED 12f0f1: 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)); 12f0f2: e9 05 c0 fd ff jmp 10b0fc <== NOT EXECUTED DIR *dirp ) { int fd; if ( !dirp ) rtems_set_errno_and_return_minus_one( EBADF ); 12f0f7: e8 e4 1c 00 00 call 130de0 <__errno> <== NOT EXECUTED 12f0fc: 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)); } 12f102: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12f107: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12f10a: 5b pop %ebx <== NOT EXECUTED 12f10b: 5e pop %esi <== NOT EXECUTED 12f10c: c9 leave <== NOT EXECUTED 12f10d: c3 ret <== NOT EXECUTED 0010f9e0 : */ int device_close( rtems_libio_t *iop ) { 10f9e0: 55 push %ebp <== NOT EXECUTED 10f9e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f9e3: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10f9e6: 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; 10f9e9: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED args.iop = iop; 10f9ec: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = 0; 10f9ef: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%ebp) <== NOT EXECUTED args.mode = 0; 10f9f6: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_close( 10f9fd: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10fa00: 50 push %eax <== NOT EXECUTED 10fa01: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED 10fa04: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED 10fa07: e8 34 04 00 00 call 10fe40 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) { 10fa0c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fa0f: 85 c0 test %eax,%eax <== NOT EXECUTED 10fa11: 75 05 jne 10fa18 <== NOT EXECUTED return rtems_deviceio_errno(status); } return 0; } 10fa13: c9 leave <== NOT EXECUTED 10fa14: c3 ret <== NOT EXECUTED 10fa15: 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); 10fa18: e8 af fe ff ff call 10f8cc <== NOT EXECUTED } return 0; } 10fa1d: c9 leave <== NOT EXECUTED 10fa1e: c3 ret <== NOT EXECUTED 0010f8c4 : int device_ftruncate( rtems_libio_t *iop, off_t length ) { 10f8c4: 55 push %ebp <== NOT EXECUTED 10f8c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 10f8c7: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f8c9: c9 leave <== NOT EXECUTED 10f8ca: c3 ret <== NOT EXECUTED 0010f8f8 : int device_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 10f8f8: 55 push %ebp <== NOT EXECUTED 10f8f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f8fb: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10f8fe: 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; 10f901: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED args.command = command; 10f904: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f907: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.buffer = buffer; 10f90a: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10f90d: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED the_jnode = iop->file_info; 10f910: 8b 52 2c mov 0x2c(%edx),%edx <== NOT EXECUTED status = rtems_io_control( 10f913: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10f916: 50 push %eax <== NOT EXECUTED 10f917: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED 10f91a: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED 10f91d: e8 5e 05 00 00 call 10fe80 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10f922: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f925: 85 c0 test %eax,%eax <== NOT EXECUTED 10f927: 75 07 jne 10f930 <== NOT EXECUTED return rtems_deviceio_errno(status); return args.ioctl_return; 10f929: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 10f92c: c9 leave <== NOT EXECUTED 10f92d: c3 ret <== NOT EXECUTED 10f92e: 66 90 xchg %ax,%ax <== NOT EXECUTED the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 10f930: e8 97 ff ff ff call 10f8cc <== NOT EXECUTED return args.ioctl_return; } 10f935: c9 leave <== NOT EXECUTED 10f936: c3 ret <== NOT EXECUTED 0010f8bc : off_t device_lseek( rtems_libio_t *iop, off_t offset, int whence ) { 10f8bc: 55 push %ebp <== NOT EXECUTED 10f8bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED return offset; } 10f8bf: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f8c2: c9 leave <== NOT EXECUTED 10f8c3: c3 ret <== NOT EXECUTED 0010fa20 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 10fa20: 55 push %ebp <== NOT EXECUTED 10fa21: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fa23: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10fa26: 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; 10fa29: 8b 50 2c mov 0x2c(%eax),%edx <== NOT EXECUTED args.iop = iop; 10fa2c: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = iop->flags; 10fa2f: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 10fa32: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED args.mode = mode; 10fa35: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 10fa38: 89 45 fc mov %eax,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_open( 10fa3b: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10fa3e: 50 push %eax <== NOT EXECUTED 10fa3f: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED 10fa42: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED 10fa45: e8 76 04 00 00 call 10fec0 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10fa4a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fa4d: 85 c0 test %eax,%eax <== NOT EXECUTED 10fa4f: 75 03 jne 10fa54 <== NOT EXECUTED return rtems_deviceio_errno(status); return 0; } 10fa51: c9 leave <== NOT EXECUTED 10fa52: c3 ret <== NOT EXECUTED 10fa53: 90 nop <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 10fa54: e8 73 fe ff ff call 10f8cc <== NOT EXECUTED return 0; } 10fa59: c9 leave <== NOT EXECUTED 10fa5a: c3 ret <== NOT EXECUTED 0010f98c : ssize_t device_read( rtems_libio_t *iop, void *buffer, size_t count ) { 10f98c: 55 push %ebp <== NOT EXECUTED 10f98d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f98f: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10f992: 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; 10f995: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED args.iop = iop; 10f998: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED args.offset = iop->offset; 10f99b: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10f99e: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED args.buffer = buffer; 10f9a1: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f9a4: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED args.count = count; 10f9a7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10f9aa: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = iop->flags; 10f9ad: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10f9b0: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED args.bytes_moved = 0; 10f9b3: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_read( 10f9ba: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10f9bd: 50 push %eax <== NOT EXECUTED 10f9be: ff 71 54 pushl 0x54(%ecx) <== NOT EXECUTED 10f9c1: ff 71 50 pushl 0x50(%ecx) <== NOT EXECUTED 10f9c4: e8 37 05 00 00 call 10ff00 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10f9c9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f9cc: 85 c0 test %eax,%eax <== NOT EXECUTED 10f9ce: 75 08 jne 10f9d8 <== NOT EXECUTED return rtems_deviceio_errno(status); return (ssize_t) args.bytes_moved; 10f9d0: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 10f9d3: c9 leave <== NOT EXECUTED 10f9d4: c3 ret <== NOT EXECUTED 10f9d5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 10f9d8: e8 ef fe ff ff call 10f8cc <== NOT EXECUTED return (ssize_t) args.bytes_moved; } 10f9dd: c9 leave <== NOT EXECUTED 10f9de: c3 ret <== NOT EXECUTED 0010f938 : ssize_t device_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 10f938: 55 push %ebp <== NOT EXECUTED 10f939: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f93b: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10f93e: 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; 10f941: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED args.iop = iop; 10f944: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED args.offset = iop->offset; 10f947: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10f94a: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED args.buffer = (void *) buffer; 10f94d: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f950: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED args.count = count; 10f953: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10f956: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = iop->flags; 10f959: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10f95c: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED args.bytes_moved = 0; 10f95f: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_write( 10f966: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10f969: 50 push %eax <== NOT EXECUTED 10f96a: ff 71 54 pushl 0x54(%ecx) <== NOT EXECUTED 10f96d: ff 71 50 pushl 0x50(%ecx) <== NOT EXECUTED 10f970: e8 cb 05 00 00 call 10ff40 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10f975: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f978: 85 c0 test %eax,%eax <== NOT EXECUTED 10f97a: 75 08 jne 10f984 <== NOT EXECUTED return rtems_deviceio_errno(status); return (ssize_t) args.bytes_moved; 10f97c: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 10f97f: c9 leave <== NOT EXECUTED 10f980: c3 ret <== NOT EXECUTED 10f981: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 10f984: e8 43 ff ff ff call 10f8cc <== NOT EXECUTED return (ssize_t) args.bytes_moved; } 10f989: c9 leave <== NOT EXECUTED 10f98a: 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 bf 1d 00 00 call 10aa40 <== 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 b4 c8 11 00 mov 0x11c8b4,%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 00123eac : fclose(group_fp); group_fp = fopen("/etc/group", "r"); } void endgrent(void) { 123eac: 55 push %ebp <== NOT EXECUTED 123ead: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123eaf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (group_fp != NULL) 123eb2: a1 84 07 16 00 mov 0x160784,%eax <== NOT EXECUTED 123eb7: 85 c0 test %eax,%eax <== NOT EXECUTED 123eb9: 74 0c je 123ec7 <== NOT EXECUTED fclose(group_fp); 123ebb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123ebe: 50 push %eax <== NOT EXECUTED 123ebf: e8 68 d0 00 00 call 130f2c <== NOT EXECUTED 123ec4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 123ec7: c9 leave <== NOT EXECUTED 123ec8: c3 ret <== NOT EXECUTED 00123ecc : fclose(passwd_fp); passwd_fp = fopen("/etc/passwd", "r"); } void endpwent(void) { 123ecc: 55 push %ebp <== NOT EXECUTED 123ecd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123ecf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (passwd_fp != NULL) 123ed2: a1 84 06 16 00 mov 0x160684,%eax <== NOT EXECUTED 123ed7: 85 c0 test %eax,%eax <== NOT EXECUTED 123ed9: 74 0c je 123ee7 <== NOT EXECUTED fclose(passwd_fp); 123edb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123ede: 50 push %eax <== NOT EXECUTED 123edf: e8 48 d0 00 00 call 130f2c <== NOT EXECUTED 123ee4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 123ee7: c9 leave <== NOT EXECUTED 123ee8: 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 b4 c8 11 00 mov 0x11c8b4,%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 03 85 11 00 push $0x118503 <== 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 b4 c8 11 00 mov 0x11c8b4,%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 03 85 11 00 push $0x118503 <== 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 b4 c8 11 00 mov 0x11c8b4,%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 05 85 11 00 push $0x118505 <== 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 0012f110 : #include int fchdir( int fd ) { 12f110: 55 push %ebp <== NOT EXECUTED 12f111: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f113: 57 push %edi <== NOT EXECUTED 12f114: 56 push %esi <== NOT EXECUTED 12f115: 53 push %ebx <== NOT EXECUTED 12f116: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 12f119: 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 ); 12f11c: 3b 15 40 84 14 00 cmp 0x148440,%edx <== NOT EXECUTED 12f122: 0f 83 cc 00 00 00 jae 12f1f4 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 12f128: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 12f12b: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 12f12e: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 12f131: 03 05 78 10 16 00 add 0x161078,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 12f137: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 12f13a: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 12f13d: 0f 84 b1 00 00 00 je 12f1f4 <== NOT EXECUTED /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 12f143: 83 e2 02 and $0x2,%edx <== NOT EXECUTED 12f146: 0f 84 d8 00 00 00 je 12f224 <== NOT EXECUTED /* * Verify you can change directory into this node. */ if ( !iop->pathinfo.ops ) { 12f14c: 8b 50 18 mov 0x18(%eax),%edx <== NOT EXECUTED 12f14f: 85 d2 test %edx,%edx <== NOT EXECUTED 12f151: 0f 84 df 00 00 00 je 12f236 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( !iop->pathinfo.ops->node_type_h ) { 12f157: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 12f15a: 85 d2 test %edx,%edx <== NOT EXECUTED 12f15c: 0f 84 d4 00 00 00 je 12f236 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) != 12f162: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12f165: 8d 58 10 lea 0x10(%eax),%ebx <== NOT EXECUTED 12f168: 53 push %ebx <== NOT EXECUTED 12f169: ff d2 call *%edx <== NOT EXECUTED 12f16b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12f16e: 48 dec %eax <== NOT EXECUTED 12f16f: 75 6f jne 12f1e0 <== NOT EXECUTED * but note the race condition. Threads who * share their rtems_filesystem_current better * be synchronized! */ saved = rtems_filesystem_current; 12f171: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED 12f176: 8d 55 d4 lea -0x2c(%ebp),%edx <== NOT EXECUTED 12f179: 89 55 d0 mov %edx,-0x30(%ebp) <== NOT EXECUTED 12f17c: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 12f17f: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12f184: 89 d7 mov %edx,%edi <== NOT EXECUTED 12f186: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED rtems_filesystem_current = iop->pathinfo; 12f188: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 12f18b: b1 04 mov $0x4,%cl <== NOT EXECUTED 12f18d: 89 de mov %ebx,%esi <== NOT EXECUTED 12f18f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* clone the current node */ if (rtems_filesystem_evaluate_path(".", 0, &loc, 0)) { 12f191: 6a 00 push $0x0 <== NOT EXECUTED 12f193: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 12f196: 56 push %esi <== NOT EXECUTED 12f197: 6a 00 push $0x0 <== NOT EXECUTED 12f199: 68 10 18 14 00 push $0x141810 <== NOT EXECUTED 12f19e: e8 89 c0 fd ff call 10b22c <== NOT EXECUTED 12f1a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12f1a6: 85 c0 test %eax,%eax <== NOT EXECUTED 12f1a8: 75 5e jne 12f208 <== NOT EXECUTED /* cloning failed; restore original and bail out */ rtems_filesystem_current = saved; return -1; } /* release the old one */ rtems_filesystem_freenode( &saved ); 12f1aa: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 12f1ad: 85 c0 test %eax,%eax <== NOT EXECUTED 12f1af: 74 13 je 12f1c4 <== NOT EXECUTED 12f1b1: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12f1b4: 85 c0 test %eax,%eax <== NOT EXECUTED 12f1b6: 74 0c je 12f1c4 <== NOT EXECUTED 12f1b8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12f1bb: 8d 55 d4 lea -0x2c(%ebp),%edx <== NOT EXECUTED 12f1be: 52 push %edx <== NOT EXECUTED 12f1bf: ff d0 call *%eax <== NOT EXECUTED 12f1c1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_current = loc; 12f1c4: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED 12f1c9: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 12f1cc: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12f1d1: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 12f1d3: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 12f1d5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12f1d8: 5b pop %ebx <== NOT EXECUTED 12f1d9: 5e pop %esi <== NOT EXECUTED 12f1da: 5f pop %edi <== NOT EXECUTED 12f1db: c9 leave <== NOT EXECUTED 12f1dc: c3 ret <== NOT EXECUTED 12f1dd: 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 ); 12f1e0: e8 fb 1b 00 00 call 130de0 <__errno> <== NOT EXECUTED 12f1e5: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 12f1eb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12f1f0: eb e3 jmp 12f1d5 <== NOT EXECUTED 12f1f2: 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); 12f1f4: e8 e7 1b 00 00 call 130de0 <__errno> <== NOT EXECUTED 12f1f9: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 12f1ff: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12f204: eb cf jmp 12f1d5 <== NOT EXECUTED 12f206: 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; 12f208: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED 12f20d: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 12f210: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12f215: 8b 75 d0 mov -0x30(%ebp),%esi <== NOT EXECUTED 12f218: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 12f21a: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12f21f: eb b4 jmp 12f1d5 <== NOT EXECUTED 12f221: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 12f224: e8 b7 1b 00 00 call 130de0 <__errno> <== NOT EXECUTED 12f229: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 12f22f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12f234: eb 9f jmp 12f1d5 <== 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 ); 12f236: e8 a5 1b 00 00 call 130de0 <__errno> <== NOT EXECUTED 12f23b: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12f241: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12f246: eb 8d jmp 12f1d5 <== NOT EXECUTED 00123708 : int fchmod( int fd, mode_t mode ) { 123708: 55 push %ebp <== NOT EXECUTED 123709: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12370b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12370e: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 123711: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 123714: 3b 15 40 84 14 00 cmp 0x148440,%edx <== NOT EXECUTED 12371a: 73 3c jae 123758 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 12371c: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 12371f: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 123722: 8d 14 85 00 00 00 00 lea 0x0(,%eax,4),%edx <== NOT EXECUTED 123729: 03 15 78 10 16 00 add 0x161078,%edx <== NOT EXECUTED rtems_libio_check_is_open(iop); 12372f: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 123732: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 123735: 74 21 je 123758 <== NOT EXECUTED /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 123737: a8 04 test $0x4,%al <== NOT EXECUTED 123739: 74 31 je 12376c <== NOT EXECUTED if ( !iop->handlers->fchmod_h ) 12373b: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 12373e: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 123741: 85 c0 test %eax,%eax <== NOT EXECUTED 123743: 74 34 je 123779 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode ); 123745: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED 123748: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED 12374b: 83 c2 10 add $0x10,%edx <== NOT EXECUTED 12374e: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED 123751: 8b 48 1c mov 0x1c(%eax),%ecx <== NOT EXECUTED } 123754: 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 ); 123755: ff e1 jmp *%ecx <== NOT EXECUTED 123757: 90 nop <== NOT EXECUTED { rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open(iop); 123758: e8 83 d6 00 00 call 130de0 <__errno> <== NOT EXECUTED 12375d: 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 ); } 123763: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 123768: c9 leave <== NOT EXECUTED 123769: c3 ret <== NOT EXECUTED 12376a: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Now process the fchmod(). */ rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 12376c: e8 6f d6 00 00 call 130de0 <__errno> <== NOT EXECUTED 123771: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 123777: eb ea jmp 123763 <== NOT EXECUTED if ( !iop->handlers->fchmod_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 123779: e8 62 d6 00 00 call 130de0 <__errno> <== NOT EXECUTED 12377e: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 123784: eb dd jmp 123763 <== NOT EXECUTED 00123788 : int fchown( int fd, uid_t owner, gid_t group ) { 123788: 55 push %ebp <== NOT EXECUTED 123789: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12378b: 56 push %esi <== NOT EXECUTED 12378c: 53 push %ebx <== NOT EXECUTED 12378d: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 123790: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 123793: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 123796: 3b 15 40 84 14 00 cmp 0x148440,%edx <== NOT EXECUTED 12379c: 73 42 jae 1237e0 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 12379e: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 1237a1: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 1237a4: 8d 14 85 00 00 00 00 lea 0x0(,%eax,4),%edx <== NOT EXECUTED 1237ab: 03 15 78 10 16 00 add 0x161078,%edx <== NOT EXECUTED rtems_libio_check_is_open(iop); 1237b1: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 1237b4: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 1237b7: 74 27 je 1237e0 <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 1237b9: a8 04 test $0x4,%al <== NOT EXECUTED 1237bb: 74 37 je 1237f4 <== NOT EXECUTED if ( !iop->pathinfo.ops->chown_h ) 1237bd: 8b 42 18 mov 0x18(%edx),%eax <== NOT EXECUTED 1237c0: 8b 48 18 mov 0x18(%eax),%ecx <== NOT EXECUTED 1237c3: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1237c5: 74 3a je 123801 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group ); 1237c7: 0f b7 c3 movzwl %bx,%eax <== NOT EXECUTED 1237ca: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 1237cd: 0f b7 c6 movzwl %si,%eax <== NOT EXECUTED 1237d0: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1237d3: 8d 42 10 lea 0x10(%edx),%eax <== NOT EXECUTED 1237d6: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 1237d9: 5b pop %ebx <== NOT EXECUTED 1237da: 5e pop %esi <== NOT EXECUTED 1237db: 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 ); 1237dc: ff e1 jmp *%ecx <== NOT EXECUTED 1237de: 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); 1237e0: e8 fb d5 00 00 call 130de0 <__errno> <== NOT EXECUTED 1237e5: 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 ); } 1237eb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1237f0: 5b pop %ebx <== NOT EXECUTED 1237f1: 5e pop %esi <== NOT EXECUTED 1237f2: c9 leave <== NOT EXECUTED 1237f3: 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 ); 1237f4: e8 e7 d5 00 00 call 130de0 <__errno> <== NOT EXECUTED 1237f9: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1237ff: eb ea jmp 1237eb <== NOT EXECUTED if ( !iop->pathinfo.ops->chown_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 123801: e8 da d5 00 00 call 130de0 <__errno> <== NOT EXECUTED 123806: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12380c: eb dd jmp 1237eb <== NOT EXECUTED 0012f248 : int fcntl( int fd, int cmd, ... ) { 12f248: 55 push %ebp <== NOT EXECUTED 12f249: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f24b: 57 push %edi <== NOT EXECUTED 12f24c: 56 push %esi <== NOT EXECUTED 12f24d: 53 push %ebx <== NOT EXECUTED 12f24e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12f251: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 12f254: 8d 5d 10 lea 0x10(%ebp),%ebx <== NOT EXECUTED int fd2; int flags; int mask; int ret = 0; rtems_libio_check_fd( fd ); 12f257: 8b 0d 40 84 14 00 mov 0x148440,%ecx <== NOT EXECUTED 12f25d: 39 ca cmp %ecx,%edx <== NOT EXECUTED 12f25f: 0f 83 7f 01 00 00 jae 12f3e4 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 12f265: 8b 35 78 10 16 00 mov 0x161078,%esi <== NOT EXECUTED 12f26b: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 12f26e: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 12f271: 8d 04 86 lea (%esi,%eax,4),%eax <== NOT EXECUTED 12f274: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED rtems_libio_check_is_open(iop); 12f277: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 12f27a: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 12f27d: 0f 84 61 01 00 00 je 12f3e4 <== NOT EXECUTED /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 12f283: 83 7d 0c 09 cmpl $0x9,0xc(%ebp) <== NOT EXECUTED 12f287: 76 13 jbe 12f29c <== NOT EXECUTED errno = ENOTSUP; ret = -1; break; default: errno = EINVAL; 12f289: e8 52 1b 00 00 call 130de0 <__errno> <== NOT EXECUTED 12f28e: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 12f294: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 12f299: eb 1d jmp 12f2b8 <== NOT EXECUTED 12f29b: 90 nop <== NOT EXECUTED /* * This switch should contain all the cases from POSIX. */ switch ( cmd ) { 12f29c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 12f29f: ff 24 85 44 55 14 00 jmp *0x145544(,%eax,4) <== NOT EXECUTED 12f2a6: 66 90 xchg %ax,%ax <== NOT EXECUTED errno = ENOTSUP; ret = -1; break; case F_GETOWN: /* for sockets. */ errno = ENOTSUP; 12f2a8: e8 33 1b 00 00 call 130de0 <__errno> <== NOT EXECUTED 12f2ad: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12f2b3: 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; } 12f2b8: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12f2ba: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12f2bd: 5b pop %ebx <== NOT EXECUTED 12f2be: 5e pop %esi <== NOT EXECUTED 12f2bf: 5f pop %edi <== NOT EXECUTED 12f2c0: c9 leave <== NOT EXECUTED 12f2c1: c3 ret <== NOT EXECUTED 12f2c2: 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 ) ); 12f2c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12f2c7: ff 33 pushl (%ebx) <== NOT EXECUTED 12f2c9: e8 72 c4 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); 12f2ce: 25 01 02 00 00 and $0x201,%eax <== NOT EXECUTED 12f2d3: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 12f2d6: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED 12f2d9: 81 e2 fe fd ff ff and $0xfffffdfe,%edx <== NOT EXECUTED 12f2df: 09 c2 or %eax,%edx <== NOT EXECUTED 12f2e1: 89 51 0c mov %edx,0xc(%ecx) <== NOT EXECUTED 12f2e4: 31 db xor %ebx,%ebx <== NOT EXECUTED 12f2e6: 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) { 12f2e9: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 12f2ec: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 12f2ef: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED 12f2f2: 85 c0 test %eax,%eax <== NOT EXECUTED 12f2f4: 74 c2 je 12f2b8 <== NOT EXECUTED int err = (*iop->handlers->fcntl_h)( cmd, iop ); 12f2f6: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12f2f9: 52 push %edx <== NOT EXECUTED 12f2fa: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 12f2fd: ff d0 call *%eax <== NOT EXECUTED 12f2ff: 89 c6 mov %eax,%esi <== NOT EXECUTED if (err) { 12f301: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12f304: 85 c0 test %eax,%eax <== NOT EXECUTED 12f306: 74 b0 je 12f2b8 <== NOT EXECUTED errno = err; 12f308: e8 d3 1a 00 00 call 130de0 <__errno> <== NOT EXECUTED 12f30d: 89 30 mov %esi,(%eax) <== NOT EXECUTED 12f30f: 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; } 12f314: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12f316: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12f319: 5b pop %ebx <== NOT EXECUTED 12f31a: 5e pop %esi <== NOT EXECUTED 12f31b: 5f pop %edi <== NOT EXECUTED 12f31c: c9 leave <== NOT EXECUTED 12f31d: c3 ret <== NOT EXECUTED 12f31e: 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 ); 12f320: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12f323: 52 push %edx <== NOT EXECUTED 12f324: e8 fb c1 fd ff call 10b524 <== NOT EXECUTED 12f329: 89 c3 mov %eax,%ebx <== NOT EXECUTED 12f32b: 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) { 12f32e: 85 db test %ebx,%ebx <== NOT EXECUTED 12f330: 79 b7 jns 12f2e9 <== NOT EXECUTED 12f332: eb 84 jmp 12f2b8 <== 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 ) ) 12f334: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 12f336: 85 c0 test %eax,%eax <== NOT EXECUTED 12f338: 0f 84 86 00 00 00 je 12f3c4 <== NOT EXECUTED iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; 12f33e: 80 ce 08 or $0x8,%dh <== NOT EXECUTED 12f341: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 12f344: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED 12f347: 31 db xor %ebx,%ebx <== NOT EXECUTED 12f349: eb 9e jmp 12f2e9 <== NOT EXECUTED 12f34b: 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); 12f34c: 89 d3 mov %edx,%ebx <== NOT EXECUTED 12f34e: c1 eb 0b shr $0xb,%ebx <== NOT EXECUTED 12f351: 83 e3 01 and $0x1,%ebx <== NOT EXECUTED 12f354: eb 93 jmp 12f2e9 <== NOT EXECUTED 12f356: 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 ); 12f358: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED if ( fd2 ) 12f35a: 85 db test %ebx,%ebx <== NOT EXECUTED 12f35c: 0f 84 9a 00 00 00 je 12f3fc <== NOT EXECUTED diop = rtems_libio_iop( fd2 ); 12f362: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED 12f364: 77 6e ja 12f3d4 <== NOT EXECUTED 12f366: 31 db xor %ebx,%ebx <== NOT EXECUTED 12f368: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) <== NOT EXECUTED ret = -1; break; } } diop->handlers = iop->handlers; 12f36f: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 12f372: 8b 41 30 mov 0x30(%ecx),%eax <== NOT EXECUTED 12f375: 89 43 30 mov %eax,0x30(%ebx) <== NOT EXECUTED diop->file_info = iop->file_info; 12f378: 8b 41 2c mov 0x2c(%ecx),%eax <== NOT EXECUTED 12f37b: 89 43 2c mov %eax,0x2c(%ebx) <== NOT EXECUTED diop->flags = iop->flags; 12f37e: 89 53 0c mov %edx,0xc(%ebx) <== NOT EXECUTED diop->pathinfo = iop->pathinfo; 12f381: 8d 7b 10 lea 0x10(%ebx),%edi <== NOT EXECUTED 12f384: 89 ce mov %ecx,%esi <== NOT EXECUTED 12f386: 83 c6 10 add $0x10,%esi <== NOT EXECUTED 12f389: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12f38e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED ret = (int) (diop - rtems_libio_iops); 12f390: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 12f393: 2b 0d 78 10 16 00 sub 0x161078,%ecx <== NOT EXECUTED 12f399: c1 f9 02 sar $0x2,%ecx <== NOT EXECUTED 12f39c: 8d 14 89 lea (%ecx,%ecx,4),%edx <== NOT EXECUTED 12f39f: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 12f3a2: 89 d0 mov %edx,%eax <== NOT EXECUTED 12f3a4: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 12f3a7: 29 d0 sub %edx,%eax <== NOT EXECUTED 12f3a9: 89 c2 mov %eax,%edx <== NOT EXECUTED 12f3ab: c1 e2 0c shl $0xc,%edx <== NOT EXECUTED 12f3ae: 01 d0 add %edx,%eax <== NOT EXECUTED 12f3b0: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED 12f3b3: 8d 04 41 lea (%ecx,%eax,2),%eax <== NOT EXECUTED 12f3b6: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 12f3b9: 01 c8 add %ecx,%eax <== NOT EXECUTED 12f3bb: 8d 1c 81 lea (%ecx,%eax,4),%ebx <== NOT EXECUTED 12f3be: e9 6b ff ff ff jmp 12f32e <== NOT EXECUTED 12f3c3: 90 nop <== NOT EXECUTED */ if ( va_arg( ap, int ) ) iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC; else iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC; 12f3c4: 80 e6 f7 and $0xf7,%dh <== NOT EXECUTED 12f3c7: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 12f3ca: 89 51 0c mov %edx,0xc(%ecx) <== NOT EXECUTED 12f3cd: 31 db xor %ebx,%ebx <== NOT EXECUTED 12f3cf: e9 15 ff ff ff jmp 12f2e9 <== NOT EXECUTED switch ( cmd ) { case F_DUPFD: /* dup */ fd2 = va_arg( ap, int ); if ( fd2 ) diop = rtems_libio_iop( fd2 ); 12f3d4: 8d 04 5b lea (%ebx,%ebx,2),%eax <== NOT EXECUTED 12f3d7: 8d 04 83 lea (%ebx,%eax,4),%eax <== NOT EXECUTED 12f3da: 8d 1c 86 lea (%esi,%eax,4),%ebx <== NOT EXECUTED 12f3dd: 89 5d f0 mov %ebx,-0x10(%ebp) <== NOT EXECUTED 12f3e0: eb 8d jmp 12f36f <== NOT EXECUTED 12f3e2: 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); 12f3e4: e8 f7 19 00 00 call 130de0 <__errno> <== NOT EXECUTED 12f3e9: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 12f3ef: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 12f3f4: e9 bf fe ff ff jmp 12f2b8 <== NOT EXECUTED 12f3f9: 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(); 12f3fc: e8 83 c2 fd ff call 10b684 <== NOT EXECUTED 12f401: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( diop == 0 ) { 12f403: 85 c0 test %eax,%eax <== NOT EXECUTED 12f405: 0f 84 04 ff ff ff je 12f30f <== NOT EXECUTED 12f40b: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 12f40e: 8b 4d ec mov -0x14(%ebp),%ecx <== NOT EXECUTED 12f411: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED 12f414: e9 56 ff ff ff jmp 12f36f <== NOT EXECUTED 00125550 : 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 ) { 125550: 55 push %ebp <== NOT EXECUTED 125551: 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; 125553: a1 2c 11 16 00 mov 0x16112c,%eax <== NOT EXECUTED !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); 125558: 3d 30 11 16 00 cmp $0x161130,%eax <== NOT EXECUTED 12555d: 74 1b je 12557a <== 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 ) { 12555f: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 125562: 8b 51 0c mov 0xc(%ecx),%edx <== NOT EXECUTED 125565: 39 50 14 cmp %edx,0x14(%eax) <== NOT EXECUTED 125568: 75 07 jne 125571 <== NOT EXECUTED 12556a: eb 14 jmp 125580 <== NOT EXECUTED 12556c: 39 50 14 cmp %edx,0x14(%eax) <== NOT EXECUTED 12556f: 74 0f je 125580 <== 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 ) { 125571: 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 ); 125573: 3d 30 11 16 00 cmp $0x161130,%eax <== NOT EXECUTED 125578: 75 f2 jne 12556c <== NOT EXECUTED 12557a: 31 c0 xor %eax,%eax <== NOT EXECUTED return true; } } return false; } 12557c: c9 leave <== NOT EXECUTED 12557d: c3 ret <== NOT EXECUTED 12557e: 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 ); 125580: b0 01 mov $0x1,%al <== NOT EXECUTED return true; } } return false; } 125582: c9 leave <== NOT EXECUTED 125583: 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 0c e9 11 00 incl 0x11e90c <== 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 c4 eb 11 00 03 cmpl $0x3,0x11ebc4 <== NOT EXECUTED 1070bb: 74 47 je 107104 <== NOT EXECUTED #endif /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 1070bd: a1 84 cd 11 00 mov 0x11cd84,%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 a0 e8 11 00 push $0x11e8a0 <== NOT EXECUTED 1070d9: e8 6e 4c 00 00 call 10bd4c <_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 bc e8 11 00 pushl 0x11e8bc <== NOT EXECUTED 1070eb: ff 35 b8 e8 11 00 pushl 0x11e8b8 <== NOT EXECUTED 1070f1: 53 push %ebx <== NOT EXECUTED 1070f2: 68 d8 83 11 00 push $0x1183d8 <== 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 00124dd8 : * NOTE: this must be called with * thread dispatching disabled! */ static void free_user_env(void *venv) { 124dd8: 55 push %ebp <== NOT EXECUTED 124dd9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124ddb: 53 push %ebx <== NOT EXECUTED 124ddc: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 124ddf: 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 124de2: 81 fb 40 16 16 00 cmp $0x161640,%ebx <== NOT EXECUTED 124de8: 74 42 je 124e2c <== NOT EXECUTED #ifdef HAVE_USERENV_REFCNT && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); 124dea: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 124ded: 85 c0 test %eax,%eax <== NOT EXECUTED 124def: 74 13 je 124e04 <== NOT EXECUTED 124df1: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 124df4: 85 d2 test %edx,%edx <== NOT EXECUTED 124df6: 74 0c je 124e04 <== NOT EXECUTED 124df8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124dfb: 8d 43 04 lea 0x4(%ebx),%eax <== NOT EXECUTED 124dfe: 50 push %eax <== NOT EXECUTED 124dff: ff d2 call *%edx <== NOT EXECUTED 124e01: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &env->root_directory); 124e04: 8b 43 1c mov 0x1c(%ebx),%eax <== NOT EXECUTED 124e07: 85 c0 test %eax,%eax <== NOT EXECUTED 124e09: 74 13 je 124e1e <== NOT EXECUTED 124e0b: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 124e0e: 85 d2 test %edx,%edx <== NOT EXECUTED 124e10: 74 0c je 124e1e <== NOT EXECUTED 124e12: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124e15: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 124e18: 50 push %eax <== NOT EXECUTED 124e19: ff d2 call *%edx <== NOT EXECUTED 124e1b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free(env); 124e1e: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 124e21: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 124e24: c9 leave <== NOT EXECUTED && --env->refcnt <= 0 #endif ) { rtems_filesystem_freenode( &env->current_directory); rtems_filesystem_freenode( &env->root_directory); free(env); 124e25: e9 46 65 fe ff jmp 10b370 <== NOT EXECUTED 124e2a: 66 90 xchg %ax,%ax <== NOT EXECUTED } } 124e2c: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 124e2f: c9 leave <== NOT EXECUTED 124e30: c3 ret <== NOT EXECUTED 001164c8 : int fstat( int fd, struct stat *sbuf ) { 1164c8: 55 push %ebp <== NOT EXECUTED 1164c9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1164cb: 57 push %edi <== NOT EXECUTED 1164cc: 56 push %esi <== NOT EXECUTED 1164cd: 53 push %ebx <== NOT EXECUTED 1164ce: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1164d1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1164d4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) 1164d7: 85 f6 test %esi,%esi <== NOT EXECUTED 1164d9: 74 7a je 116555 <== NOT EXECUTED /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); 1164db: 3b 15 e0 a3 11 00 cmp 0x11a3e0,%edx <== NOT EXECUTED 1164e1: 73 4d jae 116530 <== NOT EXECUTED 1164e3: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 1164e6: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 1164e9: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 1164f0: 03 1d 70 e8 11 00 add 0x11e870,%ebx <== NOT EXECUTED rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 1164f6: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 1164fa: 74 34 je 116530 <== NOT EXECUTED if ( !iop->handlers ) 1164fc: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 1164ff: 85 c0 test %eax,%eax <== NOT EXECUTED 116501: 74 2d je 116530 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fstat_h ) 116503: 8b 40 18 mov 0x18(%eax),%eax <== NOT EXECUTED 116506: 85 c0 test %eax,%eax <== NOT EXECUTED 116508: 74 3e je 116548 <== NOT EXECUTED /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); 11650a: b9 4c 00 00 00 mov $0x4c,%ecx <== NOT EXECUTED 11650f: 31 c0 xor %eax,%eax <== NOT EXECUTED 116511: 89 f7 mov %esi,%edi <== NOT EXECUTED 116513: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf ); 116515: 8b 53 30 mov 0x30(%ebx),%edx <== NOT EXECUTED 116518: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 11651b: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 11651e: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 116521: 8b 4a 18 mov 0x18(%edx),%ecx <== NOT EXECUTED } 116524: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 116527: 5b pop %ebx <== NOT EXECUTED 116528: 5e pop %esi <== NOT EXECUTED 116529: 5f pop %edi <== NOT EXECUTED 11652a: 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 ); 11652b: ff e1 jmp *%ecx <== NOT EXECUTED 11652d: 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 ); 116530: e8 83 9c ff ff call 1101b8 <__errno> <== NOT EXECUTED 116535: 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 ); } 11653b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 116540: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 116543: 5b pop %ebx <== NOT EXECUTED 116544: 5e pop %esi <== NOT EXECUTED 116545: 5f pop %edi <== NOT EXECUTED 116546: c9 leave <== NOT EXECUTED 116547: 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 ); 116548: e8 6b 9c ff ff call 1101b8 <__errno> <== NOT EXECUTED 11654d: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 116553: eb e6 jmp 11653b <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) rtems_set_errno_and_return_minus_one( EFAULT ); 116555: e8 5e 9c ff ff call 1101b8 <__errno> <== NOT EXECUTED 11655a: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 116560: eb d9 jmp 11653b <== NOT EXECUTED 001238c4 : #include int fsync( int fd ) { 1238c4: 55 push %ebp <== NOT EXECUTED 1238c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1238c7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1238ca: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); 1238cd: 3b 15 40 84 14 00 cmp 0x148440,%edx <== NOT EXECUTED 1238d3: 73 33 jae 123908 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 1238d5: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 1238d8: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 1238db: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 1238de: 03 05 78 10 16 00 add 0x161078,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 1238e4: 8b 50 0c mov 0xc(%eax),%edx <== NOT EXECUTED 1238e7: f6 c6 01 test $0x1,%dh <== NOT EXECUTED 1238ea: 74 1c je 123908 <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 1238ec: 83 e2 04 and $0x4,%edx <== NOT EXECUTED 1238ef: 74 2b je 12391c <== NOT EXECUTED /* * Now process the fsync(). */ if ( !iop->handlers ) 1238f1: 8b 50 30 mov 0x30(%eax),%edx <== NOT EXECUTED 1238f4: 85 d2 test %edx,%edx <== NOT EXECUTED 1238f6: 74 10 je 123908 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fsync_h ) 1238f8: 8b 4a 28 mov 0x28(%edx),%ecx <== NOT EXECUTED 1238fb: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1238fd: 74 2a je 123929 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->fsync_h)( iop ); 1238ff: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 123902: 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 ); 123903: ff e1 jmp *%ecx <== NOT EXECUTED 123905: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Now process the fsync(). */ if ( !iop->handlers ) rtems_set_errno_and_return_minus_one( EBADF ); 123908: e8 d3 d4 00 00 call 130de0 <__errno> <== NOT EXECUTED 12390d: 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 ); } 123913: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 123918: c9 leave <== NOT EXECUTED 123919: c3 ret <== NOT EXECUTED 12391a: 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 ); 12391c: e8 bf d4 00 00 call 130de0 <__errno> <== NOT EXECUTED 123921: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 123927: eb ea jmp 123913 <== 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 ); 123929: e8 b2 d4 00 00 call 130de0 <__errno> <== NOT EXECUTED 12392e: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 123934: eb dd jmp 123913 <== NOT EXECUTED 0010e528 : int ftruncate( int fd, off_t length ) { 10e528: 55 push %ebp <== NOT EXECUTED 10e529: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e52b: 57 push %edi <== NOT EXECUTED 10e52c: 56 push %esi <== NOT EXECUTED 10e52d: 53 push %ebx <== NOT EXECUTED 10e52e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10e531: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd ); 10e534: 3b 15 e0 a3 11 00 cmp 0x11a3e0,%edx <== NOT EXECUTED 10e53a: 73 64 jae 10e5a0 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 10e53c: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10e53f: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 10e542: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 10e549: 03 1d 70 e8 11 00 add 0x11e870,%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 10e54f: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 10e553: 74 4b je 10e5a0 <== NOT EXECUTED /* * Make sure we are not working on a directory */ loc = iop->pathinfo; 10e555: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 10e558: 8d 73 10 lea 0x10(%ebx),%esi <== NOT EXECUTED 10e55b: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10e560: 89 d7 mov %edx,%edi <== NOT EXECUTED 10e562: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !loc.ops->node_type_h ) 10e564: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10e567: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 10e56a: 85 c0 test %eax,%eax <== NOT EXECUTED 10e56c: 74 5a je 10e5c8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) 10e56e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e571: 52 push %edx <== NOT EXECUTED 10e572: ff d0 call *%eax <== NOT EXECUTED 10e574: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e577: 48 dec %eax <== NOT EXECUTED 10e578: 74 60 je 10e5da <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EISDIR ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10e57a: f6 43 0c 04 testb $0x4,0xc(%ebx) <== NOT EXECUTED 10e57e: 74 34 je 10e5b4 <== NOT EXECUTED if ( !iop->handlers->ftruncate_h ) 10e580: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10e583: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED 10e586: 85 c0 test %eax,%eax <== NOT EXECUTED 10e588: 74 3e je 10e5c8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->ftruncate_h)( iop, length ); 10e58a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e58d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10e590: 53 push %ebx <== NOT EXECUTED 10e591: ff d0 call *%eax <== NOT EXECUTED 10e593: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10e596: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e599: 5b pop %ebx <== NOT EXECUTED 10e59a: 5e pop %esi <== NOT EXECUTED 10e59b: 5f pop %edi <== NOT EXECUTED 10e59c: c9 leave <== NOT EXECUTED 10e59d: c3 ret <== NOT EXECUTED 10e59e: 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); 10e5a0: e8 13 1c 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10e5a5: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10e5ab: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e5b0: eb e4 jmp 10e596 <== NOT EXECUTED 10e5b2: 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 ); 10e5b4: e8 ff 1b 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10e5b9: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10e5bf: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e5c4: eb d0 jmp 10e596 <== NOT EXECUTED 10e5c6: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !iop->handlers->ftruncate_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 10e5c8: e8 eb 1b 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10e5cd: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10e5d3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e5d8: eb bc jmp 10e596 <== 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 ); 10e5da: e8 d9 1b 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10e5df: c7 00 15 00 00 00 movl $0x15,(%eax) <== NOT EXECUTED 10e5e5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e5ea: eb aa jmp 10e596 <== NOT EXECUTED 001239fc : char * getcwd ( char *pt, size_t size) { 1239fc: 55 push %ebp <== NOT EXECUTED 1239fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1239ff: 57 push %edi <== NOT EXECUTED 123a00: 56 push %esi <== NOT EXECUTED 123a01: 53 push %ebx <== NOT EXECUTED 123a02: 81 ec 9c 00 00 00 sub $0x9c,%esp <== NOT EXECUTED 123a08: 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) 123a0b: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 123a0e: 85 c9 test %ecx,%ecx <== NOT EXECUTED 123a10: 0f 84 22 04 00 00 je 123e38 <== NOT EXECUTED { ptsize = 0; if (!size) 123a16: 85 c0 test %eax,%eax <== NOT EXECUTED 123a18: 0f 84 03 04 00 00 je 123e21 <== NOT EXECUTED { errno = EINVAL; return (char *) NULL; } ept = pt + size; 123a1e: 03 45 08 add 0x8(%ebp),%eax <== NOT EXECUTED 123a21: 89 45 98 mov %eax,-0x68(%ebp) <== NOT EXECUTED 123a24: c7 45 8c 00 00 00 00 movl $0x0,-0x74(%ebp) <== NOT EXECUTED { return (char *) NULL; } ept = pt + ptsize; } bpt = ept - 1; 123a2b: 8b 45 98 mov -0x68(%ebp),%eax <== NOT EXECUTED 123a2e: 48 dec %eax <== NOT EXECUTED 123a2f: 89 45 84 mov %eax,-0x7c(%ebp) <== NOT EXECUTED *bpt = '\0'; 123a32: 8b 55 98 mov -0x68(%ebp),%edx <== NOT EXECUTED 123a35: 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))) 123a39: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123a3c: 68 fc 03 00 00 push $0x3fc <== NOT EXECUTED 123a41: e8 4e 7e fe ff call 10b894 <== NOT EXECUTED 123a46: 89 c3 mov %eax,%ebx <== NOT EXECUTED 123a48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123a4b: 85 c0 test %eax,%eax <== NOT EXECUTED 123a4d: 74 1f je 123a6e <== NOT EXECUTED { goto err; } eup = up + MAXPATHLEN; bup = up; up[0] = '.'; 123a4f: c6 00 2e movb $0x2e,(%eax) <== NOT EXECUTED up[1] = '\0'; 123a52: c6 40 01 00 movb $0x0,0x1(%eax) <== NOT EXECUTED /* Save root values, so know when to stop. */ if (stat ("/", &s)) 123a56: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 123a59: 8d 7d a8 lea -0x58(%ebp),%edi <== NOT EXECUTED 123a5c: 57 push %edi <== NOT EXECUTED 123a5d: 68 03 42 14 00 push $0x144203 <== NOT EXECUTED 123a62: e8 e9 8e fe ff call 10c950 <== NOT EXECUTED 123a67: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123a6a: 85 c0 test %eax,%eax <== NOT EXECUTED 123a6c: 74 36 je 123aa4 <== NOT EXECUTED /* FALLTHROUGH */ err: if(dir) (void) _closedir (dir); if (ptsize) 123a6e: 8b 45 8c mov -0x74(%ebp),%eax <== NOT EXECUTED 123a71: 85 c0 test %eax,%eax <== NOT EXECUTED 123a73: 75 1f jne 123a94 <== NOT EXECUTED free (pt); free (up); 123a75: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123a78: 53 push %ebx <== NOT EXECUTED 123a79: e8 f2 78 fe ff call 10b370 <== NOT EXECUTED 123a7e: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp) <== NOT EXECUTED 123a85: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return (char *) NULL; } 123a88: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 123a8b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 123a8e: 5b pop %ebx <== NOT EXECUTED 123a8f: 5e pop %esi <== NOT EXECUTED 123a90: 5f pop %edi <== NOT EXECUTED 123a91: c9 leave <== NOT EXECUTED 123a92: c3 ret <== NOT EXECUTED 123a93: 90 nop <== NOT EXECUTED err: if(dir) (void) _closedir (dir); if (ptsize) free (pt); 123a94: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123a97: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 123a9a: e8 d1 78 fe ff call 10b370 <== NOT EXECUTED 123a9f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123aa2: eb d1 jmp 123a75 <== NOT EXECUTED if (!(up = (char *) malloc (upsize = 1024 - 4))) { goto err; } eup = up + MAXPATHLEN; 123aa4: 8d 83 00 04 00 00 lea 0x400(%ebx),%eax <== NOT EXECUTED 123aaa: 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; 123aad: 8b 55 a8 mov -0x58(%ebp),%edx <== NOT EXECUTED 123ab0: 89 95 68 ff ff ff mov %edx,-0x98(%ebp) <== NOT EXECUTED 123ab6: 8b 7d ac mov -0x54(%ebp),%edi <== NOT EXECUTED 123ab9: 89 bd 64 ff ff ff mov %edi,-0x9c(%ebp) <== NOT EXECUTED root_ino = s.st_ino; 123abf: 8b 45 b0 mov -0x50(%ebp),%eax <== NOT EXECUTED 123ac2: 89 45 88 mov %eax,-0x78(%ebp) <== NOT EXECUTED errno = 0; /* XXX readdir has no error return. */ 123ac5: e8 16 d3 00 00 call 130de0 <__errno> <== NOT EXECUTED 123aca: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 123ad0: 89 de mov %ebx,%esi <== NOT EXECUTED 123ad2: c7 45 80 01 00 00 00 movl $0x1,-0x80(%ebp) <== NOT EXECUTED 123ad9: 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)) 123ae0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 123ae3: 8d 55 a8 lea -0x58(%ebp),%edx <== NOT EXECUTED 123ae6: 52 push %edx <== NOT EXECUTED 123ae7: 53 push %ebx <== NOT EXECUTED 123ae8: e8 63 8e fe ff call 10c950 <== NOT EXECUTED 123aed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123af0: 85 c0 test %eax,%eax <== NOT EXECUTED 123af2: 0f 85 76 ff ff ff jne 123a6e <== NOT EXECUTED goto err; /* Save current node values. */ ino = s.st_ino; 123af8: 8b 7d b0 mov -0x50(%ebp),%edi <== NOT EXECUTED 123afb: 89 bd 7c ff ff ff mov %edi,-0x84(%ebp) <== NOT EXECUTED dev = s.st_dev; 123b01: 8b 45 a8 mov -0x58(%ebp),%eax <== NOT EXECUTED 123b04: 89 85 60 ff ff ff mov %eax,-0xa0(%ebp) <== NOT EXECUTED 123b0a: 8b 55 ac mov -0x54(%ebp),%edx <== NOT EXECUTED 123b0d: 89 95 5c ff ff ff mov %edx,-0xa4(%ebp) <== NOT EXECUTED /* Check for reaching root. */ if (root_dev == dev && root_ino == ino) 123b13: 8b 95 64 ff ff ff mov -0x9c(%ebp),%edx <== NOT EXECUTED 123b19: 33 95 5c ff ff ff xor -0xa4(%ebp),%edx <== NOT EXECUTED 123b1f: 8b 85 68 ff ff ff mov -0x98(%ebp),%eax <== NOT EXECUTED 123b25: 33 85 60 ff ff ff xor -0xa0(%ebp),%eax <== NOT EXECUTED 123b2b: 09 c2 or %eax,%edx <== NOT EXECUTED 123b2d: 0f 84 b1 02 00 00 je 123de4 <== 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) 123b33: 8d 86 04 04 00 00 lea 0x404(%esi),%eax <== NOT EXECUTED 123b39: 39 45 9c cmp %eax,-0x64(%ebp) <== NOT EXECUTED 123b3c: 77 26 ja 123b64 <== NOT EXECUTED { if (!(up = (char *) realloc (up, upsize *= 2))) 123b3e: d1 65 90 shll -0x70(%ebp) <== NOT EXECUTED 123b41: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 123b44: ff 75 90 pushl -0x70(%ebp) <== NOT EXECUTED 123b47: 53 push %ebx <== NOT EXECUTED 123b48: e8 17 8d fe ff call 10c864 <== NOT EXECUTED 123b4d: 89 c3 mov %eax,%ebx <== NOT EXECUTED 123b4f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123b52: 85 c0 test %eax,%eax <== NOT EXECUTED 123b54: 0f 84 14 ff ff ff je 123a6e <== NOT EXECUTED { goto err; } bup = up; eup = up + upsize; 123b5a: 8b 45 90 mov -0x70(%ebp),%eax <== NOT EXECUTED 123b5d: 01 d8 add %ebx,%eax <== NOT EXECUTED 123b5f: 89 45 9c mov %eax,-0x64(%ebp) <== NOT EXECUTED 123b62: 89 de mov %ebx,%esi <== NOT EXECUTED } *bup++ = '.'; 123b64: c6 06 2e movb $0x2e,(%esi) <== NOT EXECUTED *bup++ = '.'; 123b67: c6 46 01 2e movb $0x2e,0x1(%esi) <== NOT EXECUTED 123b6b: 8d 7e 02 lea 0x2(%esi),%edi <== NOT EXECUTED *bup = '\0'; 123b6e: c6 46 02 00 movb $0x0,0x2(%esi) <== NOT EXECUTED /* Open and stat parent directory. */ if (!(dir = _opendir (up)) || _fstat (__dirfd (dir), &s)) 123b72: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123b75: 53 push %ebx <== NOT EXECUTED 123b76: e8 c1 11 00 00 call 124d3c <== NOT EXECUTED 123b7b: 89 85 78 ff ff ff mov %eax,-0x88(%ebp) <== NOT EXECUTED 123b81: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123b84: 85 c0 test %eax,%eax <== NOT EXECUTED 123b86: 0f 84 e2 fe ff ff je 123a6e <== NOT EXECUTED 123b8c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 123b8f: 8d 55 a8 lea -0x58(%ebp),%edx <== NOT EXECUTED 123b92: 52 push %edx <== NOT EXECUTED 123b93: ff 30 pushl (%eax) <== NOT EXECUTED 123b95: e8 76 fc ff ff call 123810 <== NOT EXECUTED 123b9a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123b9d: 85 c0 test %eax,%eax <== NOT EXECUTED 123b9f: 0f 85 ff 01 00 00 jne 123da4 <== NOT EXECUTED goto err; /* Add trailing slash for next directory. */ *bup++ = '/'; 123ba5: c6 07 2f movb $0x2f,(%edi) <== NOT EXECUTED 123ba8: 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) 123bab: 8b 95 5c ff ff ff mov -0xa4(%ebp),%edx <== NOT EXECUTED 123bb1: 33 55 ac xor -0x54(%ebp),%edx <== NOT EXECUTED 123bb4: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax <== NOT EXECUTED 123bba: 33 45 a8 xor -0x58(%ebp),%eax <== NOT EXECUTED 123bbd: 09 c2 or %eax,%edx <== NOT EXECUTED 123bbf: 0f 84 8f 00 00 00 je 123c54 <== NOT EXECUTED 123bc5: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) <== NOT EXECUTED } } else for (;;) { if (!(dp = _readdir (dir))) 123bcc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123bcf: ff b5 78 ff ff ff pushl -0x88(%ebp) <== NOT EXECUTED 123bd5: e8 0a 14 00 00 call 124fe4 <== NOT EXECUTED 123bda: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123bdd: 85 c0 test %eax,%eax <== NOT EXECUTED 123bdf: 0f 84 df 01 00 00 je 123dc4 <== NOT EXECUTED goto notfound; if (ISDOT (dp)) 123be5: 80 78 0c 2e cmpb $0x2e,0xc(%eax) <== NOT EXECUTED 123be9: 75 10 jne 123bfb <== NOT EXECUTED 123beb: 8a 50 0d mov 0xd(%eax),%dl <== NOT EXECUTED 123bee: 84 d2 test %dl,%dl <== NOT EXECUTED 123bf0: 74 da je 123bcc <== NOT EXECUTED 123bf2: 80 fa 2e cmp $0x2e,%dl <== NOT EXECUTED 123bf5: 0f 84 8d 01 00 00 je 123d88 <== NOT EXECUTED continue; bcopy (dp->d_name, bup, strlen (dp->d_name) + 1); 123bfb: 83 c0 0c add $0xc,%eax <== NOT EXECUTED 123bfe: 89 85 58 ff ff ff mov %eax,-0xa8(%ebp) <== NOT EXECUTED 123c04: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 123c09: 89 c7 mov %eax,%edi <== NOT EXECUTED 123c0b: 31 c0 xor %eax,%eax <== NOT EXECUTED 123c0d: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 123c0f: f7 d1 not %ecx <== NOT EXECUTED 123c11: 57 push %edi <== NOT EXECUTED 123c12: 51 push %ecx <== NOT EXECUTED 123c13: ff b5 58 ff ff ff pushl -0xa8(%ebp) <== NOT EXECUTED 123c19: 56 push %esi <== NOT EXECUTED 123c1a: e8 c1 f3 00 00 call 132fe0 <== NOT EXECUTED /* Save the first error for later. */ if (stat (up, &s)) 123c1f: 58 pop %eax <== NOT EXECUTED 123c20: 5a pop %edx <== NOT EXECUTED 123c21: 8d 45 a8 lea -0x58(%ebp),%eax <== NOT EXECUTED 123c24: 50 push %eax <== NOT EXECUTED 123c25: 53 push %ebx <== NOT EXECUTED 123c26: e8 25 8d fe ff call 10c950 <== NOT EXECUTED 123c2b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123c2e: 85 c0 test %eax,%eax <== NOT EXECUTED 123c30: 0f 84 12 01 00 00 je 123d48 <== NOT EXECUTED { if (!save_errno) 123c36: 8b 45 94 mov -0x6c(%ebp),%eax <== NOT EXECUTED 123c39: 85 c0 test %eax,%eax <== NOT EXECUTED 123c3b: 0f 84 37 01 00 00 je 123d78 <== NOT EXECUTED save_errno = errno; errno = 0; 123c41: e8 9a d1 00 00 call 130de0 <__errno> <== NOT EXECUTED 123c46: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 123c4c: e9 7b ff ff ff jmp 123bcc <== NOT EXECUTED 123c51: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED save_errno = 0; if (s.st_dev == dev) { for (;;) { if (!(dp = _readdir (dir))) 123c54: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123c57: ff b5 78 ff ff ff pushl -0x88(%ebp) <== NOT EXECUTED 123c5d: e8 82 13 00 00 call 124fe4 <== NOT EXECUTED 123c62: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123c65: 85 c0 test %eax,%eax <== NOT EXECUTED 123c67: 0f 84 4d 01 00 00 je 123dba <== NOT EXECUTED goto notfound; if (dp->d_ino == ino) 123c6d: 8b bd 7c ff ff ff mov -0x84(%ebp),%edi <== NOT EXECUTED 123c73: 39 38 cmp %edi,(%eax) <== NOT EXECUTED 123c75: 75 dd jne 123c54 <== NOT EXECUTED 123c77: 83 c0 0c add $0xc,%eax <== NOT EXECUTED 123c7a: 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)) 123c80: 8b 7d 84 mov -0x7c(%ebp),%edi <== NOT EXECUTED 123c83: 2b 7d 08 sub 0x8(%ebp),%edi <== NOT EXECUTED 123c86: 89 7d a0 mov %edi,-0x60(%ebp) <== NOT EXECUTED 123c89: 31 c0 xor %eax,%eax <== NOT EXECUTED 123c8b: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 123c90: 8b bd 58 ff ff ff mov -0xa8(%ebp),%edi <== NOT EXECUTED 123c96: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 123c98: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 123c9b: f7 d8 neg %eax <== NOT EXECUTED 123c9d: 29 c8 sub %ecx,%eax <== NOT EXECUTED 123c9f: 39 45 a0 cmp %eax,-0x60(%ebp) <== NOT EXECUTED 123ca2: 77 50 ja 123cf4 <== NOT EXECUTED { size_t len, off; if (!ptsize) 123ca4: 8b 7d 8c mov -0x74(%ebp),%edi <== NOT EXECUTED 123ca7: 85 ff test %edi,%edi <== NOT EXECUTED 123ca9: 0f 84 e8 00 00 00 je 123d97 <== NOT EXECUTED errno = ERANGE; goto err; } off = bpt - pt; len = ept - bpt; if (!(pt = (char *) realloc (pt, ptsize *= 2))) 123caf: d1 65 8c shll -0x74(%ebp) <== NOT EXECUTED 123cb2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 123cb5: ff 75 8c pushl -0x74(%ebp) <== NOT EXECUTED 123cb8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 123cbb: e8 a4 8b fe ff call 10c864 <== NOT EXECUTED 123cc0: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 123cc3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123cc6: 85 c0 test %eax,%eax <== NOT EXECUTED 123cc8: 0f 84 d6 00 00 00 je 123da4 <== NOT EXECUTED { errno = ERANGE; goto err; } off = bpt - pt; len = ept - bpt; 123cce: 8b 45 98 mov -0x68(%ebp),%eax <== NOT EXECUTED 123cd1: 2b 45 84 sub -0x7c(%ebp),%eax <== NOT EXECUTED if (!(pt = (char *) realloc (pt, ptsize *= 2))) { goto err; } bpt = pt + off; ept = pt + ptsize; 123cd4: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 123cd7: 03 55 8c add -0x74(%ebp),%edx <== NOT EXECUTED 123cda: 89 55 98 mov %edx,-0x68(%ebp) <== NOT EXECUTED (void) bcopy (bpt, ept - len, len); 123cdd: 29 c2 sub %eax,%edx <== NOT EXECUTED 123cdf: 89 55 84 mov %edx,-0x7c(%ebp) <== NOT EXECUTED 123ce2: 51 push %ecx <== NOT EXECUTED 123ce3: 50 push %eax <== NOT EXECUTED 123ce4: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 123ce7: 03 45 a0 add -0x60(%ebp),%eax <== NOT EXECUTED 123cea: 50 push %eax <== NOT EXECUTED 123ceb: 52 push %edx <== NOT EXECUTED 123cec: e8 ef f2 00 00 call 132fe0 <== NOT EXECUTED 123cf1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED bpt = ept - len; } if (!first) 123cf4: 8b 45 80 mov -0x80(%ebp),%eax <== NOT EXECUTED 123cf7: 85 c0 test %eax,%eax <== NOT EXECUTED 123cf9: 75 09 jne 123d04 <== NOT EXECUTED *--bpt = '/'; 123cfb: ff 4d 84 decl -0x7c(%ebp) <== NOT EXECUTED 123cfe: 8b 7d 84 mov -0x7c(%ebp),%edi <== NOT EXECUTED 123d01: c6 07 2f movb $0x2f,(%edi) <== NOT EXECUTED bpt -= strlen (dp->d_name); 123d04: 31 c0 xor %eax,%eax <== NOT EXECUTED 123d06: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 123d0b: 8b bd 58 ff ff ff mov -0xa8(%ebp),%edi <== NOT EXECUTED 123d11: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 123d13: f7 d1 not %ecx <== NOT EXECUTED 123d15: 49 dec %ecx <== NOT EXECUTED 123d16: 29 4d 84 sub %ecx,-0x7c(%ebp) <== NOT EXECUTED bcopy (dp->d_name, bpt, strlen (dp->d_name)); 123d19: 50 push %eax <== NOT EXECUTED 123d1a: 51 push %ecx <== NOT EXECUTED 123d1b: ff b5 58 ff ff ff pushl -0xa8(%ebp) <== NOT EXECUTED 123d21: ff 75 84 pushl -0x7c(%ebp) <== NOT EXECUTED 123d24: e8 b7 f2 00 00 call 132fe0 <== NOT EXECUTED (void) _closedir (dir); 123d29: 5f pop %edi <== NOT EXECUTED 123d2a: ff b5 78 ff ff ff pushl -0x88(%ebp) <== NOT EXECUTED 123d30: e8 83 b3 00 00 call 12f0b8 <== NOT EXECUTED dir = 0; /* Truncate any file name. */ *bup = '\0'; 123d35: c6 06 00 movb $0x0,(%esi) <== NOT EXECUTED 123d38: c7 45 80 00 00 00 00 movl $0x0,-0x80(%ebp) <== NOT EXECUTED 123d3f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123d42: e9 99 fd ff ff jmp 123ae0 <== NOT EXECUTED 123d47: 90 nop <== NOT EXECUTED if (!save_errno) save_errno = errno; errno = 0; continue; } if (s.st_dev == dev && s.st_ino == ino) 123d48: 8b 95 5c ff ff ff mov -0xa4(%ebp),%edx <== NOT EXECUTED 123d4e: 33 55 ac xor -0x54(%ebp),%edx <== NOT EXECUTED 123d51: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax <== NOT EXECUTED 123d57: 33 45 a8 xor -0x58(%ebp),%eax <== NOT EXECUTED 123d5a: 09 c2 or %eax,%edx <== NOT EXECUTED 123d5c: 0f 85 6a fe ff ff jne 123bcc <== NOT EXECUTED 123d62: 8b 95 7c ff ff ff mov -0x84(%ebp),%edx <== NOT EXECUTED 123d68: 39 55 b0 cmp %edx,-0x50(%ebp) <== NOT EXECUTED 123d6b: 0f 85 5b fe ff ff jne 123bcc <== NOT EXECUTED 123d71: e9 0a ff ff ff jmp 123c80 <== NOT EXECUTED 123d76: 66 90 xchg %ax,%ax <== NOT EXECUTED /* Save the first error for later. */ if (stat (up, &s)) { if (!save_errno) save_errno = errno; 123d78: e8 63 d0 00 00 call 130de0 <__errno> <== NOT EXECUTED 123d7d: 8b 00 mov (%eax),%eax <== NOT EXECUTED 123d7f: 89 45 94 mov %eax,-0x6c(%ebp) <== NOT EXECUTED 123d82: e9 ba fe ff ff jmp 123c41 <== NOT EXECUTED 123d87: 90 nop <== NOT EXECUTED else for (;;) { if (!(dp = _readdir (dir))) goto notfound; if (ISDOT (dp)) 123d88: 80 78 0e 00 cmpb $0x0,0xe(%eax) <== NOT EXECUTED 123d8c: 0f 84 3a fe ff ff je 123bcc <== NOT EXECUTED 123d92: e9 64 fe ff ff jmp 123bfb <== NOT EXECUTED { size_t len, off; if (!ptsize) { errno = ERANGE; 123d97: e8 44 d0 00 00 call 130de0 <__errno> <== NOT EXECUTED 123d9c: c7 00 22 00 00 00 movl $0x22,(%eax) <== NOT EXECUTED 123da2: 66 90 xchg %ax,%ax <== NOT EXECUTED errno = save_errno ? save_errno : ENOENT; /* FALLTHROUGH */ err: if(dir) (void) _closedir (dir); 123da4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123da7: ff b5 78 ff ff ff pushl -0x88(%ebp) <== NOT EXECUTED 123dad: e8 06 b3 00 00 call 12f0b8 <== NOT EXECUTED 123db2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123db5: e9 b4 fc ff ff jmp 123a6e <== NOT EXECUTED (void) _closedir (dir); dir = 0; /* Truncate any file name. */ *bup = '\0'; } 123dba: c7 45 94 00 00 00 00 movl $0x0,-0x6c(%ebp) <== NOT EXECUTED 123dc1: 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) 123dc4: e8 17 d0 00 00 call 130de0 <__errno> <== NOT EXECUTED 123dc9: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 123dcb: 85 c9 test %ecx,%ecx <== NOT EXECUTED 123dcd: 75 d5 jne 123da4 <== NOT EXECUTED errno = save_errno ? save_errno : ENOENT; 123dcf: e8 0c d0 00 00 call 130de0 <__errno> <== NOT EXECUTED 123dd4: 8b 55 94 mov -0x6c(%ebp),%edx <== NOT EXECUTED 123dd7: 85 d2 test %edx,%edx <== NOT EXECUTED 123dd9: 74 3d je 123e18 <== NOT EXECUTED 123ddb: 8b 55 94 mov -0x6c(%ebp),%edx <== NOT EXECUTED 123dde: 89 10 mov %edx,(%eax) <== NOT EXECUTED 123de0: eb c2 jmp 123da4 <== NOT EXECUTED 123de2: 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) 123de4: 39 7d 88 cmp %edi,-0x78(%ebp) <== NOT EXECUTED 123de7: 0f 85 46 fd ff ff jne 123b33 <== NOT EXECUTED { *--bpt = '/'; 123ded: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 123df0: 48 dec %eax <== NOT EXECUTED 123df1: 8b 7d 84 mov -0x7c(%ebp),%edi <== NOT EXECUTED 123df4: 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); 123df8: 52 push %edx <== NOT EXECUTED 123df9: 29 45 98 sub %eax,-0x68(%ebp) <== NOT EXECUTED 123dfc: ff 75 98 pushl -0x68(%ebp) <== NOT EXECUTED 123dff: 50 push %eax <== NOT EXECUTED 123e00: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 123e03: e8 d8 f1 00 00 call 132fe0 <== NOT EXECUTED free (up); 123e08: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 123e0b: e8 60 75 fe ff call 10b370 <== NOT EXECUTED 123e10: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123e13: e9 70 fc ff ff jmp 123a88 <== NOT EXECUTED * didn't find the current directory in its parent directory, set * errno to ENOENT. */ if (!errno) errno = save_errno ? save_errno : ENOENT; 123e18: c7 45 94 02 00 00 00 movl $0x2,-0x6c(%ebp) <== NOT EXECUTED 123e1f: eb ba jmp 123ddb <== NOT EXECUTED if (pt) { ptsize = 0; if (!size) { errno = EINVAL; 123e21: e8 ba cf 00 00 call 130de0 <__errno> <== NOT EXECUTED 123e26: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 123e2c: c7 45 08 00 00 00 00 movl $0x0,0x8(%ebp) <== NOT EXECUTED 123e33: e9 50 fc ff ff jmp 123a88 <== NOT EXECUTED } ept = pt + size; } else { if (!(pt = (char *) malloc (ptsize = 1024 - 4))) 123e38: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123e3b: 68 fc 03 00 00 push $0x3fc <== NOT EXECUTED 123e40: e8 4f 7a fe ff call 10b894 <== NOT EXECUTED 123e45: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 123e48: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 123e4b: 85 c0 test %eax,%eax <== NOT EXECUTED 123e4d: 0f 84 35 fc ff ff je 123a88 <== NOT EXECUTED { return (char *) NULL; } ept = pt + ptsize; 123e53: 05 fc 03 00 00 add $0x3fc,%eax <== NOT EXECUTED 123e58: 89 45 98 mov %eax,-0x68(%ebp) <== NOT EXECUTED 123e5b: c7 45 8c fc 03 00 00 movl $0x3fc,-0x74(%ebp) <== NOT EXECUTED 123e62: e9 c4 fb ff ff jmp 123a2b <== NOT EXECUTED 0012f438 : int getdents( int dd_fd, char *dd_buf, int dd_len ) { 12f438: 55 push %ebp <== NOT EXECUTED 12f439: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f43b: 57 push %edi <== NOT EXECUTED 12f43c: 56 push %esi <== NOT EXECUTED 12f43d: 53 push %ebx <== NOT EXECUTED 12f43e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 12f441: 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 ); 12f444: 3b 15 40 84 14 00 cmp 0x148440,%edx <== NOT EXECUTED 12f44a: 72 48 jb 12f494 <== NOT EXECUTED 12f44c: 31 db xor %ebx,%ebx <== NOT EXECUTED /* * Make sure we are working on a directory */ loc = iop->pathinfo; 12f44e: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 12f451: 8d 73 10 lea 0x10(%ebx),%esi <== NOT EXECUTED 12f454: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12f459: 89 d7 mov %edx,%edi <== NOT EXECUTED 12f45b: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !loc.ops->node_type_h ) 12f45d: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 12f460: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 12f463: 85 c0 test %eax,%eax <== NOT EXECUTED 12f465: 74 59 je 12f4c0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) 12f467: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12f46a: 52 push %edx <== NOT EXECUTED 12f46b: ff d0 call *%eax <== NOT EXECUTED 12f46d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12f470: 48 dec %eax <== NOT EXECUTED 12f471: 75 39 jne 12f4ac <== NOT EXECUTED /* * Return the number of bytes that were actually transfered as a result * of the read attempt. */ if ( !iop->handlers->read_h ) 12f473: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 12f476: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 12f479: 85 c0 test %eax,%eax <== NOT EXECUTED 12f47b: 74 43 je 12f4c0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->read_h)( iop, dd_buf, dd_len ); 12f47d: 52 push %edx <== NOT EXECUTED 12f47e: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 12f481: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 12f484: 53 push %ebx <== NOT EXECUTED 12f485: ff d0 call *%eax <== NOT EXECUTED 12f487: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 12f48a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12f48d: 5b pop %ebx <== NOT EXECUTED 12f48e: 5e pop %esi <== NOT EXECUTED 12f48f: 5f pop %edi <== NOT EXECUTED 12f490: c9 leave <== NOT EXECUTED 12f491: c3 ret <== NOT EXECUTED 12f492: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Get the file control block structure associated with the file descriptor */ iop = rtems_libio_iop( dd_fd ); 12f494: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 12f497: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 12f49a: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 12f4a1: 03 1d 78 10 16 00 add 0x161078,%ebx <== NOT EXECUTED 12f4a7: eb a5 jmp 12f44e <== NOT EXECUTED 12f4a9: 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 ); 12f4ac: e8 2f 19 00 00 call 130de0 <__errno> <== NOT EXECUTED 12f4b1: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 12f4b7: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12f4bc: eb cc jmp 12f48a <== NOT EXECUTED 12f4be: 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 ); 12f4c0: e8 1b 19 00 00 call 130de0 <__errno> <== NOT EXECUTED 12f4c5: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12f4cb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12f4d0: eb b8 jmp 12f48a <== NOT EXECUTED 00123e68 : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ gid_t getegid( void ) { 123e68: 55 push %ebp <== NOT EXECUTED 123e69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123e6b: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED 123e70: 8b 40 30 mov 0x30(%eax),%eax <== NOT EXECUTED return _POSIX_types_Egid; } 123e73: c9 leave <== NOT EXECUTED 123e74: c3 ret <== NOT EXECUTED 00123e78 : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ uid_t geteuid( void ) { 123e78: 55 push %ebp <== NOT EXECUTED 123e79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123e7b: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED 123e80: 66 8b 40 2e mov 0x2e(%eax),%ax <== NOT EXECUTED return _POSIX_types_Euid; } 123e84: c9 leave <== NOT EXECUTED 123e85: c3 ret <== NOT EXECUTED 00123e88 : * 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs, * P1003.1b-1993, p. 84 */ gid_t getgid( void ) { 123e88: 55 push %ebp <== NOT EXECUTED 123e89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123e8b: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED 123e90: 8b 40 2c mov 0x2c(%eax),%eax <== NOT EXECUTED return _POSIX_types_Gid; } 123e93: c9 leave <== NOT EXECUTED 123e94: c3 ret <== NOT EXECUTED 00124418 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 124418: 55 push %ebp <== NOT EXECUTED 124419: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12441b: 57 push %edi <== NOT EXECUTED 12441c: 56 push %esi <== NOT EXECUTED 12441d: 53 push %ebx <== NOT EXECUTED 12441e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124421: 89 c7 mov %eax,%edi <== NOT EXECUTED 124423: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 124426: 89 cb mov %ecx,%ebx <== NOT EXECUTED FILE *fp; int match; init_etc_passwd_group(); 124428: e8 af fe ff ff call 1242dc <== NOT EXECUTED if ((fp = fopen("/etc/group", "r")) == NULL) { 12442d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124430: 68 e1 19 14 00 push $0x1419e1 <== NOT EXECUTED 124435: 68 b9 40 14 00 push $0x1440b9 <== NOT EXECUTED 12443a: e8 59 d2 00 00 call 131698 <== NOT EXECUTED 12443f: 89 c6 mov %eax,%esi <== NOT EXECUTED 124441: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124444: 85 c0 test %eax,%eax <== NOT EXECUTED 124446: 75 22 jne 12446a <== NOT EXECUTED 124448: e9 8b 00 00 00 jmp 1244d8 <== NOT EXECUTED 12444d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED errno = EINVAL; fclose(fp); return -1; } if (name) { match = (strcmp(grp->gr_name, name) == 0); 124450: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124453: 57 push %edi <== NOT EXECUTED 124454: ff 33 pushl (%ebx) <== NOT EXECUTED 124456: e8 d5 0d 01 00 call 135230 <== NOT EXECUTED 12445b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12445e: 85 c0 test %eax,%eax <== NOT EXECUTED 124460: 0f 94 c0 sete %al <== NOT EXECUTED 124463: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED } else { match = (grp->gr_gid == gid); } if (match) { 124466: 85 c0 test %eax,%eax <== NOT EXECUTED 124468: 75 2e jne 124498 <== NOT EXECUTED if ((fp = fopen("/etc/group", "r")) == NULL) { errno = EINVAL; return -1; } for(;;) { if (!scangr(fp, grp, buffer, bufsize)) { 12446a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12446d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 124470: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 124473: 89 da mov %ebx,%edx <== NOT EXECUTED 124475: 89 f0 mov %esi,%eax <== NOT EXECUTED 124477: e8 dc fb ff ff call 124058 <== NOT EXECUTED 12447c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12447f: 85 c0 test %eax,%eax <== NOT EXECUTED 124481: 74 31 je 1244b4 <== NOT EXECUTED errno = EINVAL; fclose(fp); return -1; } if (name) { 124483: 85 ff test %edi,%edi <== NOT EXECUTED 124485: 75 c9 jne 124450 <== NOT EXECUTED match = (strcmp(grp->gr_name, name) == 0); } else { match = (grp->gr_gid == gid); 124487: 0f b7 43 08 movzwl 0x8(%ebx),%eax <== NOT EXECUTED 12448b: 3b 45 f0 cmp -0x10(%ebp),%eax <== NOT EXECUTED 12448e: 0f 94 c0 sete %al <== NOT EXECUTED 124491: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED } if (match) { 124494: 85 c0 test %eax,%eax <== NOT EXECUTED 124496: 74 d2 je 12446a <== NOT EXECUTED fclose(fp); 124498: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12449b: 56 push %esi <== NOT EXECUTED 12449c: e8 8b ca 00 00 call 130f2c <== NOT EXECUTED *result = grp; 1244a1: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 1244a4: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 1244a6: 31 c0 xor %eax,%eax <== NOT EXECUTED 1244a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } fclose(fp); errno = EINVAL; return -1; } 1244ab: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1244ae: 5b pop %ebx <== NOT EXECUTED 1244af: 5e pop %esi <== NOT EXECUTED 1244b0: 5f pop %edi <== NOT EXECUTED 1244b1: c9 leave <== NOT EXECUTED 1244b2: c3 ret <== NOT EXECUTED 1244b3: 90 nop <== NOT EXECUTED errno = EINVAL; return -1; } for(;;) { if (!scangr(fp, grp, buffer, bufsize)) { errno = EINVAL; 1244b4: e8 27 c9 00 00 call 130de0 <__errno> <== NOT EXECUTED 1244b9: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED fclose(fp); 1244bf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1244c2: 56 push %esi <== NOT EXECUTED 1244c3: e8 64 ca 00 00 call 130f2c <== NOT EXECUTED 1244c8: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1244cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } fclose(fp); errno = EINVAL; return -1; } 1244d0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1244d3: 5b pop %ebx <== NOT EXECUTED 1244d4: 5e pop %esi <== NOT EXECUTED 1244d5: 5f pop %edi <== NOT EXECUTED 1244d6: c9 leave <== NOT EXECUTED 1244d7: c3 ret <== NOT EXECUTED int match; init_etc_passwd_group(); if ((fp = fopen("/etc/group", "r")) == NULL) { errno = EINVAL; 1244d8: e8 03 c9 00 00 call 130de0 <__errno> <== NOT EXECUTED 1244dd: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1244e3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1244e8: eb c1 jmp 1244ab <== NOT EXECUTED 00124170 : return NULL; return p; } struct group *getgrent() { 124170: 55 push %ebp <== NOT EXECUTED 124171: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124173: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (group_fp == NULL) 124176: a1 84 07 16 00 mov 0x160784,%eax <== NOT EXECUTED 12417b: 85 c0 test %eax,%eax <== NOT EXECUTED 12417d: 74 25 je 1241a4 <== NOT EXECUTED return NULL; if (!scangr(group_fp, &grent, grbuf, sizeof grbuf)) 12417f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124182: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 124187: b9 a0 07 16 00 mov $0x1607a0,%ecx <== NOT EXECUTED 12418c: ba 68 08 16 00 mov $0x160868,%edx <== NOT EXECUTED 124191: e8 c2 fe ff ff call 124058 <== NOT EXECUTED 124196: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124199: 85 c0 test %eax,%eax <== NOT EXECUTED 12419b: 74 07 je 1241a4 <== NOT EXECUTED 12419d: b8 68 08 16 00 mov $0x160868,%eax <== NOT EXECUTED return NULL; return &grent; } 1241a2: c9 leave <== NOT EXECUTED 1241a3: c3 ret <== NOT EXECUTED struct group *getgrent() { if (group_fp == NULL) return NULL; if (!scangr(group_fp, &grent, grbuf, sizeof grbuf)) 1241a4: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; return &grent; } 1241a6: c9 leave <== NOT EXECUTED 1241a7: c3 ret <== NOT EXECUTED 00124514 : } struct group *getgrgid( gid_t gid ) { 124514: 55 push %ebp <== NOT EXECUTED 124515: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124517: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct group *p; if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p)) 12451a: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 12451d: 50 push %eax <== NOT EXECUTED 12451e: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 124523: 68 a0 07 16 00 push $0x1607a0 <== NOT EXECUTED 124528: 68 68 08 16 00 push $0x160868 <== NOT EXECUTED 12452d: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED 124531: 50 push %eax <== NOT EXECUTED 124532: e8 b5 ff ff ff call 1244ec <== NOT EXECUTED 124537: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 12453a: 85 c0 test %eax,%eax <== NOT EXECUTED 12453c: 75 06 jne 124544 <== NOT EXECUTED return NULL; return p; 12453e: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 124541: c9 leave <== NOT EXECUTED 124542: c3 ret <== NOT EXECUTED 124543: 90 nop <== NOT EXECUTED gid_t gid ) { struct group *p; if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p)) 124544: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; return p; } 124546: c9 leave <== NOT EXECUTED 124547: c3 ret <== NOT EXECUTED 001244ec : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 1244ec: 55 push %ebp <== NOT EXECUTED 1244ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1244ef: 53 push %ebx <== NOT EXECUTED 1244f0: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1244f3: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED return getgr_r(NULL, gid, grp, buffer, bufsize, result); 1244f6: 0f b7 55 08 movzwl 0x8(%ebp),%edx <== NOT EXECUTED 1244fa: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 1244fd: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 124500: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 124503: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 124506: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 124509: 31 c0 xor %eax,%eax <== NOT EXECUTED } 12450b: 5b pop %ebx <== NOT EXECUTED 12450c: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct group **result ) { return getgr_r(NULL, gid, grp, buffer, bufsize, result); 12450d: e9 06 ff ff ff jmp 124418 <== NOT EXECUTED 00124570 : } struct group *getgrnam( const char *name ) { 124570: 55 push %ebp <== NOT EXECUTED 124571: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124573: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct group *p; if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p)) 124576: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 124579: 50 push %eax <== NOT EXECUTED 12457a: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 12457f: 68 a0 07 16 00 push $0x1607a0 <== NOT EXECUTED 124584: 68 68 08 16 00 push $0x160868 <== NOT EXECUTED 124589: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12458c: e8 b7 ff ff ff call 124548 <== NOT EXECUTED 124591: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 124594: 85 c0 test %eax,%eax <== NOT EXECUTED 124596: 75 08 jne 1245a0 <== NOT EXECUTED return NULL; return p; 124598: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 12459b: c9 leave <== NOT EXECUTED 12459c: c3 ret <== NOT EXECUTED 12459d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED const char *name ) { struct group *p; if(getgrnam_r(name, &grent, grbuf, sizeof grbuf, &p)) 1245a0: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; return p; } 1245a2: c9 leave <== NOT EXECUTED 1245a3: c3 ret <== NOT EXECUTED 00124548 : struct group *grp, char *buffer, size_t bufsize, struct group **result ) { 124548: 55 push %ebp <== NOT EXECUTED 124549: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12454b: 53 push %ebx <== NOT EXECUTED 12454c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 12454f: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 124552: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED return getgr_r(name, 0, grp, buffer, bufsize, result); 124555: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 124558: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED 12455b: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 12455e: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 124561: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 124564: 31 d2 xor %edx,%edx <== NOT EXECUTED } 124566: 5b pop %ebx <== NOT EXECUTED 124567: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct group **result ) { return getgr_r(name, 0, grp, buffer, bufsize, result); 124568: e9 ab fe ff ff jmp 124418 <== NOT EXECUTED 00120e10 : * * 4.1.1 Get Process and Parent Process IDs, P1003.1b-1993, p. 83 */ pid_t getpid( void ) { 120e10: 55 push %ebp <== NOT EXECUTED 120e11: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_Local_node; } 120e13: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 120e18: c9 leave <== NOT EXECUTED 120e19: c3 ret <== NOT EXECUTED 001245e0 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 1245e0: 55 push %ebp <== NOT EXECUTED 1245e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1245e3: 57 push %edi <== NOT EXECUTED 1245e4: 56 push %esi <== NOT EXECUTED 1245e5: 53 push %ebx <== NOT EXECUTED 1245e6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1245e9: 89 c7 mov %eax,%edi <== NOT EXECUTED 1245eb: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 1245ee: 89 cb mov %ecx,%ebx <== NOT EXECUTED FILE *fp; int match; init_etc_passwd_group(); 1245f0: e8 e7 fc ff ff call 1242dc <== NOT EXECUTED if ((fp = fopen("/etc/passwd", "r")) == NULL) { 1245f5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1245f8: 68 e1 19 14 00 push $0x1419e1 <== NOT EXECUTED 1245fd: 68 ad 40 14 00 push $0x1440ad <== NOT EXECUTED 124602: e8 91 d0 00 00 call 131698 <== NOT EXECUTED 124607: 89 c6 mov %eax,%esi <== NOT EXECUTED 124609: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12460c: 85 c0 test %eax,%eax <== NOT EXECUTED 12460e: 75 22 jne 124632 <== NOT EXECUTED 124610: e9 8b 00 00 00 jmp 1246a0 <== NOT EXECUTED 124615: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED errno = EINVAL; fclose(fp); return -1; } if (name) { match = (strcmp(pwd->pw_name, name) == 0); 124618: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12461b: 57 push %edi <== NOT EXECUTED 12461c: ff 33 pushl (%ebx) <== NOT EXECUTED 12461e: e8 0d 0c 01 00 call 135230 <== NOT EXECUTED 124623: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124626: 85 c0 test %eax,%eax <== NOT EXECUTED 124628: 0f 94 c0 sete %al <== NOT EXECUTED 12462b: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED } else { match = (pwd->pw_uid == uid); } if (match) { 12462e: 85 c0 test %eax,%eax <== NOT EXECUTED 124630: 75 2e jne 124660 <== NOT EXECUTED if ((fp = fopen("/etc/passwd", "r")) == NULL) { errno = EINVAL; return -1; } for(;;) { if (!scanpw(fp, pwd, buffer, bufsize)) { 124632: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124635: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 124638: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 12463b: 89 da mov %ebx,%edx <== NOT EXECUTED 12463d: 89 f0 mov %esi,%eax <== NOT EXECUTED 12463f: e8 64 fb ff ff call 1241a8 <== NOT EXECUTED 124644: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124647: 85 c0 test %eax,%eax <== NOT EXECUTED 124649: 74 31 je 12467c <== NOT EXECUTED errno = EINVAL; fclose(fp); return -1; } if (name) { 12464b: 85 ff test %edi,%edi <== NOT EXECUTED 12464d: 75 c9 jne 124618 <== NOT EXECUTED match = (strcmp(pwd->pw_name, name) == 0); } else { match = (pwd->pw_uid == uid); 12464f: 0f b7 43 08 movzwl 0x8(%ebx),%eax <== NOT EXECUTED 124653: 3b 45 f0 cmp -0x10(%ebp),%eax <== NOT EXECUTED 124656: 0f 94 c0 sete %al <== NOT EXECUTED 124659: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED } if (match) { 12465c: 85 c0 test %eax,%eax <== NOT EXECUTED 12465e: 74 d2 je 124632 <== NOT EXECUTED fclose(fp); 124660: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124663: 56 push %esi <== NOT EXECUTED 124664: e8 c3 c8 00 00 call 130f2c <== NOT EXECUTED *result = pwd; 124669: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 12466c: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 12466e: 31 c0 xor %eax,%eax <== NOT EXECUTED 124670: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } fclose(fp); errno = EINVAL; return -1; } 124673: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124676: 5b pop %ebx <== NOT EXECUTED 124677: 5e pop %esi <== NOT EXECUTED 124678: 5f pop %edi <== NOT EXECUTED 124679: c9 leave <== NOT EXECUTED 12467a: c3 ret <== NOT EXECUTED 12467b: 90 nop <== NOT EXECUTED errno = EINVAL; return -1; } for(;;) { if (!scanpw(fp, pwd, buffer, bufsize)) { errno = EINVAL; 12467c: e8 5f c7 00 00 call 130de0 <__errno> <== NOT EXECUTED 124681: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED fclose(fp); 124687: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12468a: 56 push %esi <== NOT EXECUTED 12468b: e8 9c c8 00 00 call 130f2c <== NOT EXECUTED 124690: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 124695: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } fclose(fp); errno = EINVAL; return -1; } 124698: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12469b: 5b pop %ebx <== NOT EXECUTED 12469c: 5e pop %esi <== NOT EXECUTED 12469d: 5f pop %edi <== NOT EXECUTED 12469e: c9 leave <== NOT EXECUTED 12469f: c3 ret <== NOT EXECUTED int match; init_etc_passwd_group(); if ((fp = fopen("/etc/passwd", "r")) == NULL) { errno = EINVAL; 1246a0: e8 3b c7 00 00 call 130de0 <__errno> <== NOT EXECUTED 1246a5: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1246ab: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1246b0: eb c1 jmp 124673 <== NOT EXECUTED 001242a4 : return NULL; return p; } struct passwd *getpwent() { 1242a4: 55 push %ebp <== NOT EXECUTED 1242a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1242a7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED if (passwd_fp == NULL) 1242aa: a1 84 06 16 00 mov 0x160684,%eax <== NOT EXECUTED 1242af: 85 c0 test %eax,%eax <== NOT EXECUTED 1242b1: 74 25 je 1242d8 <== NOT EXECUTED return NULL; if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf)) 1242b3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1242b6: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 1242bb: b9 a0 06 16 00 mov $0x1606a0,%ecx <== NOT EXECUTED 1242c0: ba 68 07 16 00 mov $0x160768,%edx <== NOT EXECUTED 1242c5: e8 de fe ff ff call 1241a8 <== NOT EXECUTED 1242ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1242cd: 85 c0 test %eax,%eax <== NOT EXECUTED 1242cf: 74 07 je 1242d8 <== NOT EXECUTED 1242d1: b8 68 07 16 00 mov $0x160768,%eax <== NOT EXECUTED return NULL; return &pwent; } 1242d6: c9 leave <== NOT EXECUTED 1242d7: c3 ret <== NOT EXECUTED struct passwd *getpwent() { if (passwd_fp == NULL) return NULL; if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf)) 1242d8: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; return &pwent; } 1242da: c9 leave <== NOT EXECUTED 1242db: c3 ret <== NOT EXECUTED 00124738 : } struct passwd *getpwnam( const char *name ) { 124738: 55 push %ebp <== NOT EXECUTED 124739: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12473b: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct passwd *p; if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p)) 12473e: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 124741: 50 push %eax <== NOT EXECUTED 124742: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 124747: 68 a0 06 16 00 push $0x1606a0 <== NOT EXECUTED 12474c: 68 68 07 16 00 push $0x160768 <== NOT EXECUTED 124751: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124754: e8 b7 ff ff ff call 124710 <== NOT EXECUTED 124759: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 12475c: 85 c0 test %eax,%eax <== NOT EXECUTED 12475e: 75 08 jne 124768 <== NOT EXECUTED return NULL; return p; 124760: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 124763: c9 leave <== NOT EXECUTED 124764: c3 ret <== NOT EXECUTED 124765: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED const char *name ) { struct passwd *p; if(getpwnam_r(name, &pwent, pwbuf, sizeof pwbuf, &p)) 124768: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; return p; } 12476a: c9 leave <== NOT EXECUTED 12476b: c3 ret <== NOT EXECUTED 00124710 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 124710: 55 push %ebp <== NOT EXECUTED 124711: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124713: 53 push %ebx <== NOT EXECUTED 124714: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 124717: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 12471a: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED return getpw_r(name, 0, pwd, buffer, bufsize, result); 12471d: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 124720: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED 124723: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 124726: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 124729: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 12472c: 31 d2 xor %edx,%edx <== NOT EXECUTED } 12472e: 5b pop %ebx <== NOT EXECUTED 12472f: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct passwd **result ) { return getpw_r(name, 0, pwd, buffer, bufsize, result); 124730: e9 ab fe ff ff jmp 1245e0 <== NOT EXECUTED 001246dc : } struct passwd *getpwuid( uid_t uid ) { 1246dc: 55 push %ebp <== NOT EXECUTED 1246dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1246df: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED struct passwd *p; if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p)) 1246e2: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 1246e5: 50 push %eax <== NOT EXECUTED 1246e6: 68 c8 00 00 00 push $0xc8 <== NOT EXECUTED 1246eb: 68 a0 06 16 00 push $0x1606a0 <== NOT EXECUTED 1246f0: 68 68 07 16 00 push $0x160768 <== NOT EXECUTED 1246f5: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED 1246f9: 50 push %eax <== NOT EXECUTED 1246fa: e8 b5 ff ff ff call 1246b4 <== NOT EXECUTED 1246ff: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 124702: 85 c0 test %eax,%eax <== NOT EXECUTED 124704: 75 06 jne 12470c <== NOT EXECUTED return NULL; return p; 124706: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 124709: c9 leave <== NOT EXECUTED 12470a: c3 ret <== NOT EXECUTED 12470b: 90 nop <== NOT EXECUTED uid_t uid ) { struct passwd *p; if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p)) 12470c: 31 c0 xor %eax,%eax <== NOT EXECUTED return NULL; return p; } 12470e: c9 leave <== NOT EXECUTED 12470f: c3 ret <== NOT EXECUTED 001246b4 : struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result ) { 1246b4: 55 push %ebp <== NOT EXECUTED 1246b5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1246b7: 53 push %ebx <== NOT EXECUTED 1246b8: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1246bb: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED return getpw_r(NULL, uid, pwd, buffer, bufsize, result); 1246be: 0f b7 55 08 movzwl 0x8(%ebp),%edx <== NOT EXECUTED 1246c2: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED 1246c5: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 1246c8: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1246cb: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1246ce: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED 1246d1: 31 c0 xor %eax,%eax <== NOT EXECUTED } 1246d3: 5b pop %ebx <== NOT EXECUTED 1246d4: c9 leave <== NOT EXECUTED char *buffer, size_t bufsize, struct passwd **result ) { return getpw_r(NULL, uid, pwd, buffer, bufsize, result); 1246d5: e9 06 ff ff ff jmp 1245e0 <== NOT EXECUTED 0010e5ec : int gettimeofday( struct timeval *tp, void * __tz ) { 10e5ec: 55 push %ebp <== NOT EXECUTED 10e5ed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e5ef: 56 push %esi <== NOT EXECUTED 10e5f0: 53 push %ebx <== NOT EXECUTED 10e5f1: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10e5f4: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) { 10e5f7: 85 f6 test %esi,%esi <== NOT EXECUTED 10e5f9: 74 30 je 10e62b <== NOT EXECUTED ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 10e5fb: 9c pushf <== NOT EXECUTED 10e5fc: fa cli <== NOT EXECUTED 10e5fd: 5b pop %ebx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 10e5fe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e601: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10e604: 50 push %eax <== NOT EXECUTED 10e605: e8 ee cb ff ff call 10b1f8 <_TOD_Get> <== NOT EXECUTED * begin at @a starting_address. 10e60a: 53 push %ebx <== NOT EXECUTED 10e60b: 9d popf <== NOT EXECUTED * * @param[in] the_heap is the heap to operate upon 10e60c: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10e60f: 89 06 mov %eax,(%esi) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory 10e611: b8 d3 4d 62 10 mov $0x10624dd3,%eax <== NOT EXECUTED 10e616: f7 65 f4 mull -0xc(%ebp) <== NOT EXECUTED 10e619: c1 ea 06 shr $0x6,%edx <== NOT EXECUTED 10e61c: 89 56 04 mov %edx,0x4(%esi) <== NOT EXECUTED 10e61f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e621: 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; } 10e624: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e627: 5b pop %ebx <== NOT EXECUTED 10e628: 5e pop %esi <== NOT EXECUTED 10e629: c9 leave <== NOT EXECUTED 10e62a: c3 ret <== NOT EXECUTED void * __tz ) { /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) { errno = EFAULT; 10e62b: e8 88 1b 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10e630: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 10e636: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e63b: eb e7 jmp 10e624 <== 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 ae 14 00 mov 0x14aeec,%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 0012ec94 : */ int imfs_dir_close( rtems_libio_t *iop ) { 12ec94: 55 push %ebp <== NOT EXECUTED 12ec95: 89 e5 mov %esp,%ebp <== NOT EXECUTED * and associated memory. At present the imfs_dir_close simply * returns a successful completion status. */ return 0; } 12ec97: 31 c0 xor %eax,%eax <== NOT EXECUTED 12ec99: c9 leave <== NOT EXECUTED 12ec9a: c3 ret <== NOT EXECUTED 0012ec9c : int imfs_dir_fstat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 12ec9c: 55 push %ebp <== NOT EXECUTED 12ec9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12ec9f: 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; 12eca2: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 12eca5: 8b 10 mov (%eax),%edx <== NOT EXECUTED buf->st_dev = 0ll; 12eca7: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED 12ecad: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) <== NOT EXECUTED buf->st_ino = the_jnode->st_ino; 12ecb4: 8b 42 38 mov 0x38(%edx),%eax <== NOT EXECUTED 12ecb7: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED buf->st_mode = the_jnode->st_mode; 12ecba: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED 12ecbd: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED buf->st_nlink = the_jnode->st_nlink; 12ecc0: 8b 42 34 mov 0x34(%edx),%eax <== NOT EXECUTED 12ecc3: 66 89 41 10 mov %ax,0x10(%ecx) <== NOT EXECUTED buf->st_uid = the_jnode->st_uid; 12ecc7: 8b 42 3c mov 0x3c(%edx),%eax <== NOT EXECUTED 12ecca: 66 89 41 12 mov %ax,0x12(%ecx) <== NOT EXECUTED buf->st_gid = the_jnode->st_gid; 12ecce: 66 8b 42 3e mov 0x3e(%edx),%ax <== NOT EXECUTED 12ecd2: 66 89 41 14 mov %ax,0x14(%ecx) <== NOT EXECUTED buf->st_rdev = 0ll; 12ecd6: c7 41 18 00 00 00 00 movl $0x0,0x18(%ecx) <== NOT EXECUTED 12ecdd: c7 41 1c 00 00 00 00 movl $0x0,0x1c(%ecx) <== NOT EXECUTED buf->st_blksize = 0; 12ece4: c7 41 3c 00 00 00 00 movl $0x0,0x3c(%ecx) <== NOT EXECUTED buf->st_blocks = 0; 12eceb: c7 41 40 00 00 00 00 movl $0x0,0x40(%ecx) <== NOT EXECUTED buf->st_atime = the_jnode->stat_atime; 12ecf2: 8b 42 40 mov 0x40(%edx),%eax <== NOT EXECUTED 12ecf5: 89 41 24 mov %eax,0x24(%ecx) <== NOT EXECUTED buf->st_mtime = the_jnode->stat_mtime; 12ecf8: 8b 42 44 mov 0x44(%edx),%eax <== NOT EXECUTED 12ecfb: 89 41 2c mov %eax,0x2c(%ecx) <== NOT EXECUTED buf->st_ctime = the_jnode->stat_ctime; 12ecfe: 8b 42 48 mov 0x48(%edx),%eax <== NOT EXECUTED 12ed01: 89 41 34 mov %eax,0x34(%ecx) <== NOT EXECUTED buf->st_size = 0; 12ed04: 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 ; 12ed0b: 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 12ed0e: 83 c2 54 add $0x54,%edx <== NOT EXECUTED !rtems_chain_is_tail( the_chain, the_node ) ; 12ed11: 39 d0 cmp %edx,%eax <== NOT EXECUTED 12ed13: 74 10 je 12ed25 <== NOT EXECUTED 12ed15: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_node = the_node->next ) { buf->st_size = buf->st_size + sizeof( struct dirent ); 12ed18: 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 ) { 12ed1f: 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 ) ; 12ed21: 39 d0 cmp %edx,%eax <== NOT EXECUTED 12ed23: 75 f3 jne 12ed18 <== NOT EXECUTED buf->st_size = buf->st_size + sizeof( struct dirent ); } return 0; } 12ed25: 31 c0 xor %eax,%eax <== NOT EXECUTED 12ed27: c9 leave <== NOT EXECUTED 12ed28: c3 ret <== NOT EXECUTED 0012ed2c : off_t imfs_dir_lseek( rtems_libio_t *iop, off_t offset, int whence ) { 12ed2c: 55 push %ebp <== NOT EXECUTED 12ed2d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12ed2f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12ed32: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED switch( whence ) { 12ed35: 83 7d 10 01 cmpl $0x1,0x10(%ebp) <== NOT EXECUTED 12ed39: 76 15 jbe 12ed50 <== 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 ); 12ed3b: e8 a0 20 00 00 call 130de0 <__errno> <== NOT EXECUTED 12ed40: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 12ed46: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED break; } return 0; } 12ed4b: c9 leave <== NOT EXECUTED 12ed4c: c3 ret <== NOT EXECUTED 12ed4d: 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)) * 12ed50: b8 6b 4c a4 07 mov $0x7a44c6b,%eax <== NOT EXECUTED 12ed55: f7 61 08 mull 0x8(%ecx) <== NOT EXECUTED 12ed58: c1 ea 03 shr $0x3,%edx <== NOT EXECUTED 12ed5b: 89 d0 mov %edx,%eax <== NOT EXECUTED 12ed5d: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 12ed60: 01 d0 add %edx,%eax <== NOT EXECUTED 12ed62: 8d 04 42 lea (%edx,%eax,2),%eax <== NOT EXECUTED 12ed65: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 12ed68: 89 41 08 mov %eax,0x8(%ecx) <== NOT EXECUTED 12ed6b: 31 c0 xor %eax,%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); break; } return 0; } 12ed6d: c9 leave <== NOT EXECUTED 12ed6e: c3 ret <== NOT EXECUTED 0012ec70 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 12ec70: 55 push %ebp <== NOT EXECUTED 12ec71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12ec73: 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 ) 12ec76: 8b 42 2c mov 0x2c(%edx),%eax <== NOT EXECUTED 12ec79: 83 78 4c 01 cmpl $0x1,0x4c(%eax) <== NOT EXECUTED 12ec7d: 74 09 je 12ec88 <== NOT EXECUTED 12ec7f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED return -1; /* It wasn't a directory --> return error */ iop->offset = 0; return 0; } 12ec84: c9 leave <== NOT EXECUTED 12ec85: c3 ret <== NOT EXECUTED 12ec86: 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; 12ec88: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) <== NOT EXECUTED 12ec8f: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 12ec91: c9 leave <== NOT EXECUTED 12ec92: c3 ret <== NOT EXECUTED 0012ee4c : ssize_t imfs_dir_read( rtems_libio_t *iop, void *buffer, size_t count ) { 12ee4c: 55 push %ebp <== NOT EXECUTED 12ee4d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12ee4f: 57 push %edi <== NOT EXECUTED 12ee50: 56 push %esi <== NOT EXECUTED 12ee51: 53 push %ebx <== NOT EXECUTED 12ee52: 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; 12ee58: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 12ee5b: 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( 12ee5e: 8b 70 50 mov 0x50(%eax),%esi <== NOT EXECUTED 12ee61: 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 12ee67: 83 c0 54 add $0x54,%eax <== NOT EXECUTED 12ee6a: 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 ) ) 12ee70: 39 c6 cmp %eax,%esi <== NOT EXECUTED 12ee72: 0f 84 04 01 00 00 je 12ef7c <== NOT EXECUTED /* Move to the first of the desired directory entries */ the_node = the_chain->first; bytes_transferred = 0; first_entry = iop->offset; 12ee78: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 12ee7b: 8b 7f 08 mov 0x8(%edi),%edi <== NOT EXECUTED 12ee7e: 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); 12ee84: ba 6b 4c a4 07 mov $0x7a44c6b,%edx <== NOT EXECUTED 12ee89: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 12ee8c: f7 e2 mul %edx <== NOT EXECUTED 12ee8e: c1 ea 03 shr $0x3,%edx <== NOT EXECUTED 12ee91: 89 d0 mov %edx,%eax <== NOT EXECUTED 12ee93: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 12ee96: 01 d0 add %edx,%eax <== NOT EXECUTED 12ee98: 8d 04 42 lea (%edx,%eax,2),%eax <== NOT EXECUTED 12ee9b: 8d 04 87 lea (%edi,%eax,4),%eax <== NOT EXECUTED 12ee9e: 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; 12eea4: 85 c0 test %eax,%eax <== NOT EXECUTED 12eea6: 0f 8e d0 00 00 00 jle 12ef7c <== NOT EXECUTED 12eeac: c7 85 d4 fe ff ff 00 movl $0x0,-0x12c(%ebp) <== NOT EXECUTED 12eeb3: 00 00 00 <== NOT EXECUTED 12eeb6: 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 ); 12eeb8: 8d 95 e8 fe ff ff lea -0x118(%ebp),%edx <== NOT EXECUTED 12eebe: 89 95 c4 fe ff ff mov %edx,-0x13c(%ebp) <== NOT EXECUTED 12eec4: eb 34 jmp 12eefa <== NOT EXECUTED 12eec6: 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; 12eec8: 8b 85 c0 fe ff ff mov -0x140(%ebp),%eax <== NOT EXECUTED 12eece: 8b 00 mov (%eax),%eax <== NOT EXECUTED 12eed0: 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 ) { 12eed6: 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; 12eedc: 39 9d dc fe ff ff cmp %ebx,-0x124(%ebp) <== NOT EXECUTED 12eee2: 0f 8e a0 00 00 00 jle 12ef88 <== NOT EXECUTED current_entry = current_entry + sizeof(struct dirent) ){ if ( rtems_chain_is_tail( the_chain, the_node ) ){ 12eee8: 8b b5 e0 fe ff ff mov -0x120(%ebp),%esi <== NOT EXECUTED 12eeee: 39 b5 c0 fe ff ff cmp %esi,-0x140(%ebp) <== NOT EXECUTED 12eef4: 0f 84 8e 00 00 00 je 12ef88 <== NOT EXECUTED /* entry in the read */ return bytes_transferred; /* Indicate that there are no more */ /* entries to return */ } if( current_entry >= first_entry ) { 12eefa: 39 9d d8 fe ff ff cmp %ebx,-0x128(%ebp) <== NOT EXECUTED 12ef00: 7f c6 jg 12eec8 <== NOT EXECUTED /* Move the entry to the return buffer */ tmp_dirent.d_off = current_entry; 12ef02: 89 9d ec fe ff ff mov %ebx,-0x114(%ebp) <== NOT EXECUTED tmp_dirent.d_reclen = sizeof( struct dirent ); 12ef08: 66 c7 85 f0 fe ff ff movw $0x10c,-0x110(%ebp) <== NOT EXECUTED 12ef0f: 0c 01 <== NOT EXECUTED the_jnode = (IMFS_jnode_t *) the_node; tmp_dirent.d_ino = the_jnode->st_ino; 12ef11: 8b bd c0 fe ff ff mov -0x140(%ebp),%edi <== NOT EXECUTED 12ef17: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 12ef1a: 89 85 e8 fe ff ff mov %eax,-0x118(%ebp) <== NOT EXECUTED tmp_dirent.d_namlen = strlen( the_jnode->name ); 12ef20: 89 fa mov %edi,%edx <== NOT EXECUTED 12ef22: 83 c2 0c add $0xc,%edx <== NOT EXECUTED 12ef25: 31 c0 xor %eax,%eax <== NOT EXECUTED 12ef27: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 12ef2c: 89 d7 mov %edx,%edi <== NOT EXECUTED 12ef2e: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 12ef30: f7 d1 not %ecx <== NOT EXECUTED 12ef32: 49 dec %ecx <== NOT EXECUTED 12ef33: 66 89 8d f2 fe ff ff mov %cx,-0x10e(%ebp) <== NOT EXECUTED strcpy( tmp_dirent.d_name, the_jnode->name ); 12ef3a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12ef3d: 52 push %edx <== NOT EXECUTED 12ef3e: 8d 85 f4 fe ff ff lea -0x10c(%ebp),%eax <== NOT EXECUTED 12ef44: 50 push %eax <== NOT EXECUTED 12ef45: e8 4a 63 00 00 call 135294 <== NOT EXECUTED memcpy( 12ef4a: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 12ef4d: 03 bd d4 fe ff ff add -0x12c(%ebp),%edi <== NOT EXECUTED 12ef53: b9 43 00 00 00 mov $0x43,%ecx <== NOT EXECUTED 12ef58: 8b b5 c4 fe ff ff mov -0x13c(%ebp),%esi <== NOT EXECUTED 12ef5e: 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); 12ef60: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 12ef63: 81 47 08 0c 01 00 00 addl $0x10c,0x8(%edi) <== NOT EXECUTED bytes_transferred = bytes_transferred + sizeof( struct dirent ); 12ef6a: 81 85 d4 fe ff ff 0c addl $0x10c,-0x12c(%ebp) <== NOT EXECUTED 12ef71: 01 00 00 <== NOT EXECUTED 12ef74: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12ef77: e9 4c ff ff ff jmp 12eec8 <== 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; 12ef7c: c7 85 d4 fe ff ff 00 movl $0x0,-0x12c(%ebp) <== NOT EXECUTED 12ef83: 00 00 00 <== NOT EXECUTED 12ef86: 66 90 xchg %ax,%ax <== NOT EXECUTED the_node = the_node->next; } /* Success */ return bytes_transferred; } 12ef88: 8b 85 d4 fe ff ff mov -0x12c(%ebp),%eax <== NOT EXECUTED 12ef8e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12ef91: 5b pop %ebx <== NOT EXECUTED 12ef92: 5e pop %esi <== NOT EXECUTED 12ef93: 5f pop %edi <== NOT EXECUTED 12ef94: c9 leave <== NOT EXECUTED 12ef95: c3 ret <== NOT EXECUTED 0012ed70 : */ int imfs_dir_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 12ed70: 55 push %ebp <== NOT EXECUTED 12ed71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12ed73: 56 push %esi <== NOT EXECUTED 12ed74: 53 push %ebx <== NOT EXECUTED 12ed75: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 12ed78: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 12ed7b: 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 ) ) 12ed7d: 8d 43 54 lea 0x54(%ebx),%eax <== NOT EXECUTED 12ed80: 39 43 50 cmp %eax,0x50(%ebx) <== NOT EXECUTED 12ed83: 0f 85 8f 00 00 00 jne 12ee18 <== NOT EXECUTED /* * You cannot remove the file system root node. */ if ( pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access ) 12ed89: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 12ed8c: 3b 58 18 cmp 0x18(%eax),%ebx <== NOT EXECUTED 12ed8f: 0f 84 97 00 00 00 je 12ee2c <== NOT EXECUTED /* * You cannot remove a mountpoint. */ if ( the_jnode->info.directory.mt_fs != NULL ) 12ed95: 8b 53 5c mov 0x5c(%ebx),%edx <== NOT EXECUTED 12ed98: 85 d2 test %edx,%edx <== NOT EXECUTED 12ed9a: 0f 85 8c 00 00 00 jne 12ee2c <== NOT EXECUTED /* * Take the node out of the parent's chain that contains this node */ if ( the_jnode->Parent != NULL ) { 12eda0: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 12eda3: 85 c0 test %eax,%eax <== NOT EXECUTED 12eda5: 74 13 je 12edba <== NOT EXECUTED 12eda7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12edaa: 53 push %ebx <== NOT EXECUTED 12edab: e8 4c 0f fe ff call 10fcfc <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 12edb0: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED 12edb7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 12edba: 66 ff 4b 34 decw 0x34(%ebx) <== NOT EXECUTED IMFS_update_ctime( the_jnode ); 12edbe: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12edc1: 6a 00 push $0x0 <== NOT EXECUTED 12edc3: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 12edc6: 50 push %eax <== NOT EXECUTED 12edc7: e8 20 c6 fd ff call 10b3ec <== NOT EXECUTED 12edcc: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 12edcf: 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) ) { 12edd2: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 12edd5: e8 8a c7 fd ff call 10b564 <== NOT EXECUTED 12edda: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12eddd: 85 c0 test %eax,%eax <== NOT EXECUTED 12eddf: 75 2b jne 12ee0c <== NOT EXECUTED 12ede1: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) <== NOT EXECUTED 12ede6: 75 24 jne 12ee0c <== NOT EXECUTED /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 12ede8: 8b 15 ec ae 14 00 mov 0x14aeec,%edx <== NOT EXECUTED 12edee: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 12edf1: 3b 06 cmp (%esi),%eax <== NOT EXECUTED 12edf3: 74 4b je 12ee40 <== NOT EXECUTED /* * Free memory associated with a memory file. */ free( the_jnode ); 12edf5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12edf8: 53 push %ebx <== NOT EXECUTED 12edf9: e8 72 c5 fd ff call 10b370 <== NOT EXECUTED 12edfe: 31 c0 xor %eax,%eax <== NOT EXECUTED 12ee00: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 12ee03: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12ee06: 5b pop %ebx <== NOT EXECUTED 12ee07: 5e pop %esi <== NOT EXECUTED 12ee08: c9 leave <== NOT EXECUTED 12ee09: c3 ret <== NOT EXECUTED 12ee0a: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Free memory associated with a memory file. */ free( the_jnode ); 12ee0c: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 12ee0e: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12ee11: 5b pop %ebx <== NOT EXECUTED 12ee12: 5e pop %esi <== NOT EXECUTED 12ee13: c9 leave <== NOT EXECUTED 12ee14: c3 ret <== NOT EXECUTED 12ee15: 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 ); 12ee18: e8 c3 1f 00 00 call 130de0 <__errno> <== NOT EXECUTED 12ee1d: c7 00 5a 00 00 00 movl $0x5a,(%eax) <== NOT EXECUTED 12ee23: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12ee28: eb e4 jmp 12ee0e <== NOT EXECUTED 12ee2a: 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 ); 12ee2c: e8 af 1f 00 00 call 130de0 <__errno> <== NOT EXECUTED 12ee31: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED 12ee37: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 12ee3c: eb d0 jmp 12ee0e <== NOT EXECUTED 12ee3e: 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; 12ee40: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 12ee47: eb ac jmp 12edf5 <== NOT EXECUTED 001242dc : /* * Initialize useable but dummy databases */ void init_etc_passwd_group(void) { 1242dc: 55 push %ebp <== NOT EXECUTED 1242dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1242df: 53 push %ebx <== NOT EXECUTED 1242e0: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED FILE *fp; static char etc_passwd_initted = 0; if (etc_passwd_initted) 1242e3: 80 3d 80 06 16 00 00 cmpb $0x0,0x160680 <== NOT EXECUTED 1242ea: 74 08 je 1242f4 <== NOT EXECUTED fprintf( fp, "root:x:0:root\n" "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); } } 1242ec: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1242ef: c9 leave <== NOT EXECUTED 1242f0: c3 ret <== NOT EXECUTED 1242f1: 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; 1242f4: c6 05 80 06 16 00 01 movb $0x1,0x160680 <== NOT EXECUTED mkdir("/etc", 0777); 1242fb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1242fe: 68 ff 01 00 00 push $0x1ff <== NOT EXECUTED 124303: 68 a8 40 14 00 push $0x1440a8 <== NOT EXECUTED 124308: e8 e7 76 fe ff call 10b9f4 <== NOT EXECUTED /* * Initialize /etc/passwd */ if ((fp = fopen("/etc/passwd", "r")) != NULL) { 12430d: 59 pop %ecx <== NOT EXECUTED 12430e: 5b pop %ebx <== NOT EXECUTED 12430f: 68 e1 19 14 00 push $0x1419e1 <== NOT EXECUTED 124314: 68 ad 40 14 00 push $0x1440ad <== NOT EXECUTED 124319: e8 7a d3 00 00 call 131698 <== NOT EXECUTED 12431e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124321: 85 c0 test %eax,%eax <== NOT EXECUTED 124323: 74 77 je 12439c <== NOT EXECUTED fclose(fp); 124325: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124328: 50 push %eax <== NOT EXECUTED 124329: e8 fe cb 00 00 call 130f2c <== NOT EXECUTED 12432e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { 124331: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124334: 68 e1 19 14 00 push $0x1419e1 <== NOT EXECUTED 124339: 68 b9 40 14 00 push $0x1440b9 <== NOT EXECUTED 12433e: e8 55 d3 00 00 call 131698 <== NOT EXECUTED 124343: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124346: 85 c0 test %eax,%eax <== NOT EXECUTED 124348: 74 12 je 12435c <== NOT EXECUTED fclose(fp); 12434a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12434d: 50 push %eax <== NOT EXECUTED 12434e: e8 d9 cb 00 00 call 130f2c <== NOT EXECUTED 124353: 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); } } 124356: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 124359: c9 leave <== NOT EXECUTED 12435a: c3 ret <== NOT EXECUTED 12435b: 90 nop <== NOT EXECUTED * Initialize /etc/group */ if ((fp = fopen("/etc/group", "r")) != NULL) { fclose(fp); } else if ((fp = fopen("/etc/group", "w")) != NULL) { 12435c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12435f: 68 9e 15 14 00 push $0x14159e <== NOT EXECUTED 124364: 68 b9 40 14 00 push $0x1440b9 <== NOT EXECUTED 124369: e8 2a d3 00 00 call 131698 <== NOT EXECUTED 12436e: 89 c3 mov %eax,%ebx <== NOT EXECUTED 124370: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124373: 85 c0 test %eax,%eax <== NOT EXECUTED 124375: 0f 84 71 ff ff ff je 1242ec <== NOT EXECUTED fprintf( fp, "root:x:0:root\n" 12437b: 50 push %eax <== NOT EXECUTED 12437c: 6a 2a push $0x2a <== NOT EXECUTED 12437e: 6a 01 push $0x1 <== NOT EXECUTED 124380: 68 2c 41 14 00 push $0x14412c <== NOT EXECUTED 124385: e8 7e de 00 00 call 132208 <== NOT EXECUTED "rtems:x:1:rtems\n" "tty:x:2:tty\n" ); fclose(fp); 12438a: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 12438d: e8 9a cb 00 00 call 130f2c <== NOT EXECUTED 124392: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124395: e9 52 ff ff ff jmp 1242ec <== NOT EXECUTED 12439a: 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) { 12439c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12439f: 68 9e 15 14 00 push $0x14159e <== NOT EXECUTED 1243a4: 68 ad 40 14 00 push $0x1440ad <== NOT EXECUTED 1243a9: e8 ea d2 00 00 call 131698 <== NOT EXECUTED 1243ae: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1243b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1243b3: 85 c0 test %eax,%eax <== NOT EXECUTED 1243b5: 0f 84 76 ff ff ff je 124331 <== NOT EXECUTED fprintf(fp, "root:*:0:0:root::/:/bin/sh\n" 1243bb: 50 push %eax <== NOT EXECUTED 1243bc: 6a 66 push $0x66 <== NOT EXECUTED 1243be: 6a 01 push $0x1 <== NOT EXECUTED 1243c0: 68 c4 40 14 00 push $0x1440c4 <== NOT EXECUTED 1243c5: e8 3e de 00 00 call 132208 <== NOT EXECUTED "rtems:*:1:1:RTEMS Application::/:/bin/sh\n" "tty:!:2:2:tty owner::/:/bin/false\n" ); fclose(fp); 1243ca: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1243cd: e8 5a cb 00 00 call 130f2c <== NOT EXECUTED 1243d2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1243d5: e9 57 ff ff ff jmp 124331 <== NOT EXECUTED 0010e8d4 : * This routine will initialize the chain control element that manages the * mount table chain. */ int init_fs_mount_table(void) { 10e8d4: 55 push %ebp <== NOT EXECUTED 10e8d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e8d7: c7 05 00 ed 11 00 04 movl $0x11ed04,0x11ed00 <== NOT EXECUTED 10e8de: ed 11 00 <== NOT EXECUTED 10e8e1: c7 05 04 ed 11 00 00 movl $0x0,0x11ed04 <== NOT EXECUTED 10e8e8: 00 00 00 <== NOT EXECUTED 10e8eb: c7 05 08 ed 11 00 00 movl $0x11ed00,0x11ed08 <== NOT EXECUTED 10e8f2: ed 11 00 <== NOT EXECUTED rtems_chain_initialize_empty ( &rtems_filesystem_mount_table_control ); return 0; } 10e8f5: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e8f7: c9 leave <== NOT EXECUTED 10e8f8: c3 ret <== NOT EXECUTED 001185e8 : int ioctl( int fd, ioctl_command_t command, ... ) { 1185e8: 55 push %ebp <== NOT EXECUTED 1185e9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1185eb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1185ee: 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 ); 1185f1: 3b 15 20 72 12 00 cmp 0x127220,%edx <== NOT EXECUTED 1185f7: 73 37 jae 118630 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 1185f9: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 1185fc: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 1185ff: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 118602: 03 05 54 c8 12 00 add 0x12c854,%eax <== NOT EXECUTED rtems_libio_check_is_open(iop); 118608: f6 40 0d 01 testb $0x1,0xd(%eax) <== NOT EXECUTED 11860c: 74 22 je 118630 <== NOT EXECUTED va_start(ap, command); buffer = va_arg(ap, void *); 11860e: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED /* * Now process the ioctl(). */ if ( !iop->handlers ) 118611: 8b 50 30 mov 0x30(%eax),%edx <== NOT EXECUTED 118614: 85 d2 test %edx,%edx <== NOT EXECUTED 118616: 74 18 je 118630 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->ioctl_h ) 118618: 8b 52 10 mov 0x10(%edx),%edx <== NOT EXECUTED 11861b: 85 d2 test %edx,%edx <== NOT EXECUTED 11861d: 74 23 je 118642 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); rc = (*iop->handlers->ioctl_h)( iop, command, buffer ); 11861f: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 118622: 51 push %ecx <== NOT EXECUTED 118623: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 118626: 50 push %eax <== NOT EXECUTED 118627: ff d2 call *%edx <== NOT EXECUTED 118629: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return rc; } 11862c: c9 leave <== NOT EXECUTED 11862d: c3 ret <== NOT EXECUTED 11862e: 66 90 xchg %ax,%ax <== NOT EXECUTED /* * Now process the ioctl(). */ if ( !iop->handlers ) rtems_set_errno_and_return_minus_one( EBADF ); 118630: e8 e3 05 00 00 call 118c18 <__errno> <== NOT EXECUTED 118635: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 11863b: 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; } 118640: c9 leave <== NOT EXECUTED 118641: 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 ); 118642: e8 d1 05 00 00 call 118c18 <__errno> <== NOT EXECUTED 118647: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11864d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED rc = (*iop->handlers->ioctl_h)( iop, command, buffer ); return rc; } 118652: c9 leave <== NOT EXECUTED 118653: 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 b4 c8 11 00 mov 0x11c8b4,%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 24 c8 11 00 mov 0x11c824,%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 0011657c : #include int isatty( int fd ) { 11657c: 55 push %ebp <== NOT EXECUTED 11657d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11657f: 83 ec 60 sub $0x60,%esp <== NOT EXECUTED struct stat buf; if (fstat (fd, &buf) < 0) 116582: 8d 45 b4 lea -0x4c(%ebp),%eax <== NOT EXECUTED 116585: 50 push %eax <== NOT EXECUTED 116586: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 116589: e8 3a ff ff ff call 1164c8 <== NOT EXECUTED 11658e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116591: 85 c0 test %eax,%eax <== NOT EXECUTED 116593: 78 17 js 1165ac <== NOT EXECUTED 116595: 8b 45 c0 mov -0x40(%ebp),%eax <== NOT EXECUTED 116598: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 11659d: 3d 00 20 00 00 cmp $0x2000,%eax <== NOT EXECUTED 1165a2: 0f 94 c0 sete %al <== NOT EXECUTED 1165a5: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED if (S_ISCHR (buf.st_mode)) return 1; return 0; } 1165a8: c9 leave <== NOT EXECUTED 1165a9: c3 ret <== NOT EXECUTED 1165aa: 66 90 xchg %ax,%ax <== NOT EXECUTED int fd ) { struct stat buf; if (fstat (fd, &buf) < 0) 1165ac: 31 c0 xor %eax,%eax <== NOT EXECUTED if (S_ISCHR (buf.st_mode)) return 1; return 0; } 1165ae: c9 leave <== NOT EXECUTED 1165af: c3 ret <== NOT EXECUTED 00120f44 : * These are directly supported (and completely correct) in the posix api. */ #if !defined(RTEMS_POSIX_API) int kill( pid_t pid, int sig ) { 120f44: 55 push %ebp <== NOT EXECUTED 120f45: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 120f47: 31 c0 xor %eax,%eax <== NOT EXECUTED 120f49: c9 leave <== NOT EXECUTED 120f4a: c3 ret <== 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 49 5e 00 00 call 10d3dc <_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 10 84 11 00 movl $0x118410,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 20 c4 11 00 cmp $0x11c420,%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 89 93 00 00 call 110870 <_fwalk> <== NOT EXECUTED #if REENT_MALLOCED free(ptr); #else _Workspace_Free(ptr); 1074e7: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1074ea: e8 d5 5e 00 00 call 10d3c4 <_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 c0 c8 11 00 00 movl $0x0,0x11c8c0 <== 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 c0 c8 11 00 mov 0x11c8c0,%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 c0 c8 11 00 20 movl $0x11c420,0x11c8c0 <== NOT EXECUTED 1074a2: c4 11 00 <== NOT EXECUTED 1074a5: c7 05 84 ea 11 00 c0 movl $0x11c8c0,0x11ea84 <== NOT EXECUTED 1074ac: c8 11 00 <== NOT EXECUTED _Thread_Set_libc_reent (&_REENT); } 1074af: c9 leave <== NOT EXECUTED 1074b0: c3 ret <== NOT EXECUTED 00116698 : extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) { 116698: 55 push %ebp <== NOT EXECUTED 116699: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11669b: 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())) 11669e: 83 3d c4 eb 11 00 03 cmpl $0x3,0x11ebc4 <== NOT EXECUTED 1166a5: 74 05 je 1166ac <== NOT EXECUTED */ fclose (stdin); fclose (stdout); fclose (stderr); } 1166a7: c9 leave <== NOT EXECUTED 1166a8: c3 ret <== NOT EXECUTED 1166a9: 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) { 1166ac: 81 3d c0 c8 11 00 20 cmpl $0x11c420,0x11c8c0 <== NOT EXECUTED 1166b3: c4 11 00 <== NOT EXECUTED 1166b6: 74 1a je 1166d2 <== NOT EXECUTED _wrapup_reent(&libc_global_reent); 1166b8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1166bb: 68 20 c4 11 00 push $0x11c420 <== NOT EXECUTED 1166c0: e8 eb 05 00 00 call 116cb0 <_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; 1166c5: c7 05 c0 c8 11 00 20 movl $0x11c420,0x11c8c0 <== NOT EXECUTED 1166cc: c4 11 00 <== NOT EXECUTED 1166cf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * * Should this be changed to do *all* file streams? * _fwalk (_REENT, fclose); */ fclose (stdin); 1166d2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1166d5: a1 c0 c8 11 00 mov 0x11c8c0,%eax <== NOT EXECUTED 1166da: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED 1166dd: e8 22 9c ff ff call 110304 <== NOT EXECUTED fclose (stdout); 1166e2: 5a pop %edx <== NOT EXECUTED 1166e3: a1 c0 c8 11 00 mov 0x11c8c0,%eax <== NOT EXECUTED 1166e8: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 1166eb: e8 14 9c ff ff call 110304 <== NOT EXECUTED fclose (stderr); 1166f0: 58 pop %eax <== NOT EXECUTED 1166f1: a1 c0 c8 11 00 mov 0x11c8c0,%eax <== NOT EXECUTED 1166f6: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 1166f9: e8 06 9c ff ff call 110304 <== NOT EXECUTED 1166fe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 116701: c9 leave <== NOT EXECUTED 116702: c3 ret <== NOT EXECUTED 0012480c : int link( const char *existing, const char *new ) { 12480c: 55 push %ebp <== NOT EXECUTED 12480d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12480f: 57 push %edi <== NOT EXECUTED 124810: 56 push %esi <== NOT EXECUTED 124811: 53 push %ebx <== NOT EXECUTED 124812: 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 ); 124815: 6a 01 push $0x1 <== NOT EXECUTED 124817: 8d 5d e0 lea -0x20(%ebp),%ebx <== NOT EXECUTED 12481a: 53 push %ebx <== NOT EXECUTED 12481b: 6a 00 push $0x0 <== NOT EXECUTED 12481d: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124820: e8 07 6a fe ff call 10b22c <== NOT EXECUTED if ( result != 0 ) 124825: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124828: 85 c0 test %eax,%eax <== NOT EXECUTED 12482a: 0f 85 dc 00 00 00 jne 12490c <== NOT EXECUTED /* * Get the parent of the node we are creating. */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); 124830: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 124833: 8a 02 mov (%edx),%al <== NOT EXECUTED 124835: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 124837: 74 0c je 124845 <== NOT EXECUTED 124839: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 12483b: 74 08 je 124845 <== NOT EXECUTED 12483d: 84 c0 test %al,%al <== NOT EXECUTED 12483f: 0f 85 d7 00 00 00 jne 12491c <== NOT EXECUTED 124845: 8d 7d d0 lea -0x30(%ebp),%edi <== NOT EXECUTED 124848: 89 7d b8 mov %edi,-0x48(%ebp) <== NOT EXECUTED 12484b: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED 124850: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 124853: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 124858: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 12485a: b1 01 mov $0x1,%cl <== NOT EXECUTED if ( !parent_loc.ops->evalformake_h ) { 12485c: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 12485f: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 124862: 85 d2 test %edx,%edx <== NOT EXECUTED 124864: 0f 84 80 00 00 00 je 1248ea <== 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 ); 12486a: 56 push %esi <== NOT EXECUTED 12486b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 12486e: 50 push %eax <== NOT EXECUTED 12486f: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 124872: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 124875: 01 c8 add %ecx,%eax <== NOT EXECUTED 124877: 50 push %eax <== NOT EXECUTED 124878: ff d2 call *%edx <== NOT EXECUTED 12487a: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( result != 0 ) { 12487c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12487f: 85 c0 test %eax,%eax <== NOT EXECUTED 124881: 0f 85 fd 00 00 00 jne 124984 <== 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 ) { 124887: 8b 45 dc mov -0x24(%ebp),%eax <== NOT EXECUTED 12488a: 3b 45 ec cmp -0x14(%ebp),%eax <== NOT EXECUTED 12488d: 0f 85 a9 00 00 00 jne 12493c <== 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 ) { 124893: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 124896: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 124899: 85 c0 test %eax,%eax <== NOT EXECUTED 12489b: 0f 84 0b 01 00 00 je 1249ac <== 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 ); 1248a1: 52 push %edx <== NOT EXECUTED 1248a2: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 1248a5: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 1248a8: 53 push %ebx <== NOT EXECUTED 1248a9: ff d0 call *%eax <== NOT EXECUTED 1248ab: 89 c6 mov %eax,%esi <== NOT EXECUTED rtems_filesystem_freenode( &existing_loc ); 1248ad: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1248b0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1248b3: 85 c0 test %eax,%eax <== NOT EXECUTED 1248b5: 74 10 je 1248c7 <== NOT EXECUTED 1248b7: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1248ba: 85 c0 test %eax,%eax <== NOT EXECUTED 1248bc: 74 09 je 1248c7 <== NOT EXECUTED 1248be: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1248c1: 53 push %ebx <== NOT EXECUTED 1248c2: ff d0 call *%eax <== NOT EXECUTED 1248c4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 1248c7: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 1248ca: 85 c0 test %eax,%eax <== NOT EXECUTED 1248cc: 74 12 je 1248e0 <== NOT EXECUTED 1248ce: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1248d1: 85 c0 test %eax,%eax <== NOT EXECUTED 1248d3: 74 0b je 1248e0 <== NOT EXECUTED 1248d5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1248d8: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 1248db: ff d0 call *%eax <== NOT EXECUTED 1248dd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 1248e0: 89 f0 mov %esi,%eax <== NOT EXECUTED 1248e2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1248e5: 5b pop %ebx <== NOT EXECUTED 1248e6: 5e pop %esi <== NOT EXECUTED 1248e7: 5f pop %edi <== NOT EXECUTED 1248e8: c9 leave <== NOT EXECUTED 1248e9: c3 ret <== NOT EXECUTED */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); if ( !parent_loc.ops->evalformake_h ) { rtems_filesystem_freenode( &existing_loc ); 1248ea: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1248ed: 85 c0 test %eax,%eax <== NOT EXECUTED 1248ef: 74 10 je 124901 <== NOT EXECUTED 1248f1: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1248f4: 85 c0 test %eax,%eax <== NOT EXECUTED 1248f6: 74 09 je 124901 <== NOT EXECUTED 1248f8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1248fb: 53 push %ebx <== NOT EXECUTED 1248fc: ff d0 call *%eax <== NOT EXECUTED 1248fe: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 124901: e8 da c4 00 00 call 130de0 <__errno> <== NOT EXECUTED 124906: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12490c: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED rtems_filesystem_freenode( &existing_loc ); rtems_filesystem_freenode( &parent_loc ); return result; } 124911: 89 f0 mov %esi,%eax <== NOT EXECUTED 124913: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124916: 5b pop %ebx <== NOT EXECUTED 124917: 5e pop %esi <== NOT EXECUTED 124918: 5f pop %edi <== NOT EXECUTED 124919: c9 leave <== NOT EXECUTED 12491a: c3 ret <== NOT EXECUTED 12491b: 90 nop <== NOT EXECUTED /* * Get the parent of the node we are creating. */ rtems_filesystem_get_start_loc( new, &i, &parent_loc ); 12491c: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 12491f: 89 45 b8 mov %eax,-0x48(%ebp) <== NOT EXECUTED 124922: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED 124927: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 12492a: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 12492f: 8b 7d b8 mov -0x48(%ebp),%edi <== NOT EXECUTED 124932: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 124934: e9 23 ff ff ff jmp 12485c <== NOT EXECUTED 124939: 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 ); 12493c: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 12493f: 85 c0 test %eax,%eax <== NOT EXECUTED 124941: 74 10 je 124953 <== NOT EXECUTED 124943: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 124946: 85 c0 test %eax,%eax <== NOT EXECUTED 124948: 74 09 je 124953 <== NOT EXECUTED 12494a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12494d: 53 push %ebx <== NOT EXECUTED 12494e: ff d0 call *%eax <== NOT EXECUTED 124950: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 124953: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 124956: 85 c0 test %eax,%eax <== NOT EXECUTED 124958: 74 12 je 12496c <== NOT EXECUTED 12495a: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12495d: 85 c0 test %eax,%eax <== NOT EXECUTED 12495f: 74 0b je 12496c <== NOT EXECUTED 124961: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124964: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 124967: ff d0 call *%eax <== NOT EXECUTED 124969: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EXDEV ); 12496c: e8 6f c4 00 00 call 130de0 <__errno> <== NOT EXECUTED 124971: c7 00 12 00 00 00 movl $0x12,(%eax) <== NOT EXECUTED 124977: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 12497c: e9 5f ff ff ff jmp 1248e0 <== NOT EXECUTED 124981: 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 ); 124984: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 124987: 85 c0 test %eax,%eax <== NOT EXECUTED 124989: 74 10 je 12499b <== NOT EXECUTED 12498b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12498e: 85 c0 test %eax,%eax <== NOT EXECUTED 124990: 74 09 je 12499b <== NOT EXECUTED 124992: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124995: 53 push %ebx <== NOT EXECUTED 124996: ff d0 call *%eax <== NOT EXECUTED 124998: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( result ); 12499b: e8 40 c4 00 00 call 130de0 <__errno> <== NOT EXECUTED 1249a0: 89 30 mov %esi,(%eax) <== NOT EXECUTED 1249a2: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 1249a7: e9 34 ff ff ff jmp 1248e0 <== 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 ); 1249ac: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1249af: 85 c0 test %eax,%eax <== NOT EXECUTED 1249b1: 74 13 je 1249c6 <== NOT EXECUTED 1249b3: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1249b6: 85 c0 test %eax,%eax <== NOT EXECUTED 1249b8: 74 0c je 1249c6 <== NOT EXECUTED 1249ba: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1249bd: 53 push %ebx <== NOT EXECUTED 1249be: ff d0 call *%eax <== NOT EXECUTED 1249c0: 8b 55 d8 mov -0x28(%ebp),%edx <== NOT EXECUTED 1249c3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &parent_loc ); 1249c6: 85 d2 test %edx,%edx <== NOT EXECUTED 1249c8: 74 12 je 1249dc <== NOT EXECUTED 1249ca: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 1249cd: 85 c0 test %eax,%eax <== NOT EXECUTED 1249cf: 74 0b je 1249dc <== NOT EXECUTED 1249d1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1249d4: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 1249d7: ff d0 call *%eax <== NOT EXECUTED 1249d9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1249dc: e8 ff c3 00 00 call 130de0 <__errno> <== NOT EXECUTED 1249e1: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1249e7: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 1249ec: e9 ef fe ff ff jmp 1248e0 <== NOT EXECUTED 001165b0 : off_t lseek( int fd, off_t offset, int whence ) { 1165b0: 55 push %ebp <== NOT EXECUTED 1165b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1165b3: 57 push %edi <== NOT EXECUTED 1165b4: 56 push %esi <== NOT EXECUTED 1165b5: 53 push %ebx <== NOT EXECUTED 1165b6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1165b9: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1165bc: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 1165bf: 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 ); 1165c2: 3b 15 e0 a3 11 00 cmp 0x11a3e0,%edx <== NOT EXECUTED 1165c8: 73 7e jae 116648 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 1165ca: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 1165cd: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 1165d0: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 1165d7: 03 1d 70 e8 11 00 add 0x11e870,%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 1165dd: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 1165e1: 74 65 je 116648 <== NOT EXECUTED /* * Check as many errors as possible before touching iop->offset. */ if ( !iop->handlers->lseek_h ) 1165e3: 8b 53 30 mov 0x30(%ebx),%edx <== NOT EXECUTED 1165e6: 8b 7a 14 mov 0x14(%edx),%edi <== NOT EXECUTED 1165e9: 85 ff test %edi,%edi <== NOT EXECUTED 1165eb: 74 6d je 11665a <== NOT EXECUTED /* * Now process the lseek(). */ old_offset = iop->offset; 1165ed: 8b 7b 08 mov 0x8(%ebx),%edi <== NOT EXECUTED switch ( whence ) { 1165f0: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED 1165f3: 74 4b je 116640 <== NOT EXECUTED 1165f5: 83 f9 02 cmp $0x2,%ecx <== NOT EXECUTED 1165f8: 74 22 je 11661c <== NOT EXECUTED 1165fa: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1165fc: 75 2a jne 116628 <== NOT EXECUTED case SEEK_SET: iop->offset = offset; 1165fe: 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 ); 116601: 50 push %eax <== NOT EXECUTED 116602: 51 push %ecx <== NOT EXECUTED 116603: 56 push %esi <== NOT EXECUTED 116604: 53 push %ebx <== NOT EXECUTED 116605: ff 52 14 call *0x14(%edx) <== NOT EXECUTED if ( status == (off_t) -1 ) 116608: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11660b: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 11660e: 75 03 jne 116613 <== NOT EXECUTED iop->offset = old_offset; 116610: 89 7b 08 mov %edi,0x8(%ebx) <== NOT EXECUTED /* * So if the operation failed, we have to restore iop->offset. */ return status; } 116613: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116616: 5b pop %ebx <== NOT EXECUTED 116617: 5e pop %esi <== NOT EXECUTED 116618: 5f pop %edi <== NOT EXECUTED 116619: c9 leave <== NOT EXECUTED 11661a: c3 ret <== NOT EXECUTED 11661b: 90 nop <== NOT EXECUTED case SEEK_CUR: iop->offset += offset; break; case SEEK_END: iop->offset = iop->size + offset; 11661c: 89 f0 mov %esi,%eax <== NOT EXECUTED 11661e: 03 43 04 add 0x4(%ebx),%eax <== NOT EXECUTED 116621: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED 116624: eb db jmp 116601 <== NOT EXECUTED 116626: 66 90 xchg %ax,%ax <== NOT EXECUTED break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 116628: e8 8b 9b ff ff call 1101b8 <__errno> <== NOT EXECUTED 11662d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 116633: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED /* * So if the operation failed, we have to restore iop->offset. */ return status; } 116638: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11663b: 5b pop %ebx <== NOT EXECUTED 11663c: 5e pop %esi <== NOT EXECUTED 11663d: 5f pop %edi <== NOT EXECUTED 11663e: c9 leave <== NOT EXECUTED 11663f: c3 ret <== NOT EXECUTED case SEEK_SET: iop->offset = offset; break; case SEEK_CUR: iop->offset += offset; 116640: 8d 04 3e lea (%esi,%edi,1),%eax <== NOT EXECUTED 116643: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED 116646: eb b9 jmp 116601 <== 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); 116648: e8 6b 9b ff ff call 1101b8 <__errno> <== NOT EXECUTED 11664d: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 116653: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 116658: eb b9 jmp 116613 <== 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 ); 11665a: e8 59 9b ff ff call 1101b8 <__errno> <== NOT EXECUTED 11665f: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 116665: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 11666a: eb a7 jmp 116613 <== NOT EXECUTED 00124ae4 : int _STAT_NAME( const char *path, struct stat *buf ) { 124ae4: 55 push %ebp <== NOT EXECUTED 124ae5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124ae7: 57 push %edi <== NOT EXECUTED 124ae8: 56 push %esi <== NOT EXECUTED 124ae9: 53 push %ebx <== NOT EXECUTED 124aea: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 124aed: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !buf ) 124af0: 85 db test %ebx,%ebx <== NOT EXECUTED 124af2: 0f 84 8c 00 00 00 je 124b84 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); status = rtems_filesystem_evaluate_path( path, 0, &loc, _STAT_FOLLOW_LINKS ); 124af8: 6a 00 push $0x0 <== NOT EXECUTED 124afa: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 124afd: 56 push %esi <== NOT EXECUTED 124afe: 6a 00 push $0x0 <== NOT EXECUTED 124b00: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124b03: e8 24 67 fe ff call 10b22c <== NOT EXECUTED if ( status != 0 ) 124b08: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124b0b: 85 c0 test %eax,%eax <== NOT EXECUTED 124b0d: 75 65 jne 124b74 <== NOT EXECUTED return -1; if ( !loc.handlers->fstat_h ){ 124b0f: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 124b12: 8b 42 18 mov 0x18(%edx),%eax <== NOT EXECUTED 124b15: 85 c0 test %eax,%eax <== NOT EXECUTED 124b17: 74 39 je 124b52 <== NOT EXECUTED /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( buf, 0, sizeof(struct stat) ); 124b19: b9 4c 00 00 00 mov $0x4c,%ecx <== NOT EXECUTED 124b1e: 31 c0 xor %eax,%eax <== NOT EXECUTED 124b20: 89 df mov %ebx,%edi <== NOT EXECUTED 124b22: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED status = (*loc.handlers->fstat_h)( &loc, buf ); 124b24: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124b27: 53 push %ebx <== NOT EXECUTED 124b28: 56 push %esi <== NOT EXECUTED 124b29: ff 52 18 call *0x18(%edx) <== NOT EXECUTED 124b2c: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 124b2e: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 124b31: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124b34: 85 c0 test %eax,%eax <== NOT EXECUTED 124b36: 74 10 je 124b48 <== NOT EXECUTED 124b38: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 124b3b: 85 c0 test %eax,%eax <== NOT EXECUTED 124b3d: 74 09 je 124b48 <== NOT EXECUTED 124b3f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124b42: 56 push %esi <== NOT EXECUTED 124b43: ff d0 call *%eax <== NOT EXECUTED 124b45: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return status; } 124b48: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124b4a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124b4d: 5b pop %ebx <== NOT EXECUTED 124b4e: 5e pop %esi <== NOT EXECUTED 124b4f: 5f pop %edi <== NOT EXECUTED 124b50: c9 leave <== NOT EXECUTED 124b51: 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 ); 124b52: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 124b55: 85 c0 test %eax,%eax <== NOT EXECUTED 124b57: 74 10 je 124b69 <== NOT EXECUTED 124b59: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 124b5c: 85 c0 test %eax,%eax <== NOT EXECUTED 124b5e: 74 09 je 124b69 <== NOT EXECUTED 124b60: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124b63: 56 push %esi <== NOT EXECUTED 124b64: ff d0 call *%eax <== NOT EXECUTED 124b66: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 124b69: e8 72 c2 00 00 call 130de0 <__errno> <== NOT EXECUTED 124b6e: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 124b74: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED status = (*loc.handlers->fstat_h)( &loc, buf ); rtems_filesystem_freenode( &loc ); return status; } 124b79: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124b7b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124b7e: 5b pop %ebx <== NOT EXECUTED 124b7f: 5e pop %esi <== NOT EXECUTED 124b80: 5f pop %edi <== NOT EXECUTED 124b81: c9 leave <== NOT EXECUTED 124b82: c3 ret <== NOT EXECUTED 124b83: 90 nop <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !buf ) rtems_set_errno_and_return_minus_one( EFAULT ); 124b84: e8 57 c2 00 00 call 130de0 <__errno> <== NOT EXECUTED 124b89: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 124b8f: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED status = (*loc.handlers->fstat_h)( &loc, buf ); rtems_filesystem_freenode( &loc ); return status; } 124b94: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124b96: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124b99: 5b pop %ebx <== NOT EXECUTED 124b9a: 5e pop %esi <== NOT EXECUTED 124b9b: 5f pop %edi <== NOT EXECUTED 124b9c: c9 leave <== NOT EXECUTED 124b9d: 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 04 e9 11 00 incl 0x11e904 <== 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 c4 eb 11 00 03 cmpl $0x3,0x11ebc4 <== 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 a0 e8 11 00 push $0x11e8a0 <== NOT EXECUTED 1072e5: e8 2e 4a 00 00 call 10bd18 <_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 8c cd 11 00 mov 0x11cd8c,%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 84 cd 11 00 mov 0x11cd84,%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 88 cd 11 00 mov 0x11cd88,%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 5e 8e 00 00 call 1101b8 <__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 7c e8 11 00 push $0x11e87c <== NOT EXECUTED 107206: e8 2d 3b 00 00 call 10ad38 <_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 7c e8 11 00 80 movl $0x11e880,0x11e87c <== NOT EXECUTED 1071de: e8 11 00 <== NOT EXECUTED 1071e1: c7 05 80 e8 11 00 00 movl $0x0,0x11e880 <== NOT EXECUTED 1071e8: 00 00 00 <== NOT EXECUTED 1071eb: c7 05 84 e8 11 00 7c movl $0x11e87c,0x11e884 <== NOT EXECUTED 1071f2: e8 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 7c e8 11 00 push $0x11e87c <== NOT EXECUTED 10722c: e8 2b 3b 00 00 call 10ad5c <_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 a0 10 16 00 push $0x1610a0 <== NOT EXECUTED 10b80b: e8 24 59 00 00 call 111134 <_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 00124bb8 : */ int malloc_info( Heap_Information_block *the_info ) { 124bb8: 55 push %ebp <== NOT EXECUTED 124bb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124bbb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124bbe: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !the_info ) 124bc1: 85 c0 test %eax,%eax <== NOT EXECUTED 124bc3: 74 17 je 124bdc <== NOT EXECUTED return -1; _Protected_heap_Get_information( &RTEMS_Malloc_Heap, the_info ); 124bc5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124bc8: 50 push %eax <== NOT EXECUTED 124bc9: 68 a0 10 16 00 push $0x1610a0 <== NOT EXECUTED 124bce: e8 55 20 00 00 call 126c28 <_Protected_heap_Get_information> <== NOT EXECUTED 124bd3: 31 c0 xor %eax,%eax <== NOT EXECUTED 124bd5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 124bd8: c9 leave <== NOT EXECUTED 124bd9: c3 ret <== NOT EXECUTED 124bda: 66 90 xchg %ax,%ax <== NOT EXECUTED int malloc_info( Heap_Information_block *the_info ) { if ( !the_info ) 124bdc: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED return -1; _Protected_heap_Get_information( &RTEMS_Malloc_Heap, the_info ); return 0; } 124be1: c9 leave <== NOT EXECUTED 124be2: 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 f8 e9 11 00 mov 0x11e9f8,%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 98 ea 11 00 mov 0x11ea98,%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 00124be4 : void malloc_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 124be4: 55 push %ebp <== NOT EXECUTED 124be5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124be7: 57 push %edi <== NOT EXECUTED 124be8: 56 push %esi <== NOT EXECUTED 124be9: 53 push %ebx <== NOT EXECUTED 124bea: 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; 124bed: 8b 0d 1c 11 16 00 mov 0x16111c,%ecx <== NOT EXECUTED 124bf3: 8b 1d 20 11 16 00 mov 0x161120,%ebx <== NOT EXECUTED 124bf9: a1 24 11 16 00 mov 0x161124,%eax <== NOT EXECUTED 124bfe: 8b 15 28 11 16 00 mov 0x161128,%edx <== NOT EXECUTED 124c04: 89 ce mov %ecx,%esi <== NOT EXECUTED 124c06: 29 c6 sub %eax,%esi <== NOT EXECUTED 124c08: 89 75 f0 mov %esi,-0x10(%ebp) <== NOT EXECUTED (*print)( 124c0b: 8b 3d 18 11 16 00 mov 0x161118,%edi <== NOT EXECUTED 124c11: 8b 35 00 11 16 00 mov 0x161100,%esi <== NOT EXECUTED 124c17: 0f ac d0 0a shrd $0xa,%edx,%eax <== NOT EXECUTED 124c1b: c1 ea 0a shr $0xa,%edx <== NOT EXECUTED 124c1e: 50 push %eax <== NOT EXECUTED 124c1f: 0f ac d9 0a shrd $0xa,%ebx,%ecx <== NOT EXECUTED 124c23: c1 eb 0a shr $0xa,%ebx <== NOT EXECUTED 124c26: 51 push %ecx <== NOT EXECUTED 124c27: 8d 04 bf lea (%edi,%edi,4),%eax <== NOT EXECUTED 124c2a: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 124c2d: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 124c30: 31 d2 xor %edx,%edx <== NOT EXECUTED 124c32: f7 f6 div %esi <== NOT EXECUTED 124c34: 50 push %eax <== NOT EXECUTED 124c35: c1 ef 0a shr $0xa,%edi <== NOT EXECUTED 124c38: 57 push %edi <== NOT EXECUTED 124c39: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 124c3c: 8d 04 92 lea (%edx,%edx,4),%eax <== NOT EXECUTED 124c3f: 8d 04 80 lea (%eax,%eax,4),%eax <== NOT EXECUTED 124c42: c1 e0 02 shl $0x2,%eax <== NOT EXECUTED 124c45: 31 d2 xor %edx,%edx <== NOT EXECUTED 124c47: f7 f6 div %esi <== NOT EXECUTED 124c49: 50 push %eax <== NOT EXECUTED 124c4a: c1 6d f0 0a shrl $0xa,-0x10(%ebp) <== NOT EXECUTED 124c4e: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 124c51: c1 ee 0a shr $0xa,%esi <== NOT EXECUTED 124c54: 56 push %esi <== NOT EXECUTED 124c55: 68 58 41 14 00 push $0x144158 <== NOT EXECUTED 124c5a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124c5d: 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)( 124c60: 83 c4 28 add $0x28,%esp <== NOT EXECUTED 124c63: ff 35 14 11 16 00 pushl 0x161114 <== NOT EXECUTED 124c69: ff 35 10 11 16 00 pushl 0x161110 <== NOT EXECUTED 124c6f: ff 35 0c 11 16 00 pushl 0x16110c <== NOT EXECUTED 124c75: ff 35 04 11 16 00 pushl 0x161104 <== NOT EXECUTED 124c7b: 68 bc 41 14 00 push $0x1441bc <== NOT EXECUTED 124c80: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124c83: ff 55 0c call *0xc(%ebp) <== NOT EXECUTED 124c86: 83 c4 20 add $0x20,%esp <== NOT EXECUTED s->malloc_calls, s->free_calls, s->realloc_calls, s->calloc_calls ); } 124c89: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124c8c: 5b pop %ebx <== NOT EXECUTED 124c8d: 5e pop %esi <== NOT EXECUTED 124c8e: 5f pop %edi <== NOT EXECUTED 124c8f: c9 leave <== NOT EXECUTED 124c90: 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 a0 3a 12 00 push $0x123aa0 <== NOT EXECUTED 108838: e8 5b 55 00 00 call 10dd98 <_Protected_heap_Walk> <== NOT EXECUTED 10883d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 108840: c9 leave <== NOT EXECUTED 108841: c3 ret <== NOT EXECUTED 00129100 : */ int memfile_blocks_allocated = 0; void *memfile_alloc_block(void) { 129100: 55 push %ebp <== NOT EXECUTED 129101: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129103: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED void *memory; memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK); 129106: ff 35 b0 de 14 00 pushl 0x14deb0 <== NOT EXECUTED 12910c: 6a 01 push $0x1 <== NOT EXECUTED 12910e: e8 f5 1e fe ff call 10b008 <== NOT EXECUTED if ( memory ) 129113: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129116: 85 c0 test %eax,%eax <== NOT EXECUTED 129118: 74 06 je 129120 <== NOT EXECUTED memfile_blocks_allocated++; 12911a: ff 05 78 08 16 00 incl 0x160878 <== NOT EXECUTED return memory; } 129120: c9 leave <== NOT EXECUTED 129121: c3 ret <== NOT EXECUTED 00129560 : return memfile_check_rmnod( the_jnode ); } int memfile_check_rmnod( IMFS_jnode_t *the_jnode ){ 129560: 55 push %ebp <== NOT EXECUTED 129561: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129563: 53 push %ebx <== NOT EXECUTED 129564: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 129567: 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) ) { 12956a: 53 push %ebx <== NOT EXECUTED 12956b: e8 f4 1f fe ff call 10b564 <== NOT EXECUTED 129570: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129573: 85 c0 test %eax,%eax <== NOT EXECUTED 129575: 75 2f jne 1295a6 <== NOT EXECUTED 129577: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) <== NOT EXECUTED 12957c: 75 28 jne 1295a6 <== NOT EXECUTED /* * Is the rtems_filesystem_current is this node? */ if ( rtems_filesystem_current.node_access == the_jnode ) 12957e: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED 129583: 39 58 04 cmp %ebx,0x4(%eax) <== NOT EXECUTED 129586: 74 28 je 1295b0 <== NOT EXECUTED rtems_filesystem_current.node_access = NULL; /* * Free memory associated with a memory file. */ if (the_jnode->type != IMFS_LINEAR_FILE) 129588: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) <== NOT EXECUTED 12958c: 74 0c je 12959a <== NOT EXECUTED IMFS_memfile_remove( the_jnode ); 12958e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129591: 53 push %ebx <== NOT EXECUTED 129592: e8 19 fe ff ff call 1293b0 <== NOT EXECUTED 129597: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free( the_jnode ); 12959a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12959d: 53 push %ebx <== NOT EXECUTED 12959e: e8 cd 1d fe ff call 10b370 <== NOT EXECUTED 1295a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 1295a6: 31 c0 xor %eax,%eax <== NOT EXECUTED 1295a8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1295ab: c9 leave <== NOT EXECUTED 1295ac: c3 ret <== NOT EXECUTED 1295ad: 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; 1295b0: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax) <== NOT EXECUTED 1295b7: eb cf jmp 129588 <== NOT EXECUTED 00129608 : */ int memfile_close( rtems_libio_t *iop ) { 129608: 55 push %ebp <== NOT EXECUTED 129609: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12960b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12960e: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 129611: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED if (iop->flags & LIBIO_FLAGS_APPEND) 129614: f6 42 0d 02 testb $0x2,0xd(%edx) <== NOT EXECUTED 129618: 74 06 je 129620 <== NOT EXECUTED iop->offset = the_jnode->info.file.size; 12961a: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 12961d: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED memfile_check_rmnod( the_jnode ); 129620: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 129623: 51 push %ecx <== NOT EXECUTED 129624: e8 37 ff ff ff call 129560 <== NOT EXECUTED return 0; } 129629: 31 c0 xor %eax,%eax <== NOT EXECUTED 12962b: c9 leave <== NOT EXECUTED 12962c: c3 ret <== NOT EXECUTED 001290e4 : */ void memfile_free_block( void *memory ) { 1290e4: 55 push %ebp <== NOT EXECUTED 1290e5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1290e7: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED #if 0 fprintf(stdout, "(d %p) ", memory ); fflush(stdout); #endif free(memory); 1290ea: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1290ed: e8 7e 22 fe ff call 10b370 <== NOT EXECUTED memfile_blocks_allocated--; 1290f2: ff 0d 78 08 16 00 decl 0x160878 <== NOT EXECUTED 1290f8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1290fb: c9 leave <== NOT EXECUTED 1290fc: c3 ret <== NOT EXECUTED 00129334 : void memfile_free_blocks_in_table( block_p **block_table, int entries ) { 129334: 55 push %ebp <== NOT EXECUTED 129335: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129337: 57 push %edi <== NOT EXECUTED 129338: 56 push %esi <== NOT EXECUTED 129339: 53 push %ebx <== NOT EXECUTED 12933a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12933d: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED /* * Perform internal consistency checks */ assert( block_table ); 129340: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129343: 85 c0 test %eax,%eax <== NOT EXECUTED 129345: 74 4e je 129395 <== NOT EXECUTED /* * Now go through all the slots in the table and free the memory. */ b = *block_table; 129347: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 12934a: 8b 30 mov (%eax),%esi <== NOT EXECUTED for ( i=0 ; i <== NOT EXECUTED 129350: 31 db xor %ebx,%ebx <== NOT EXECUTED 129352: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( b[i] ) { 129354: 8b 04 9e mov (%esi,%ebx,4),%eax <== NOT EXECUTED 129357: 85 c0 test %eax,%eax <== NOT EXECUTED 129359: 74 13 je 12936e <== NOT EXECUTED memfile_free_block( b[i] ); 12935b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12935e: 50 push %eax <== NOT EXECUTED 12935f: e8 80 fd ff ff call 1290e4 <== NOT EXECUTED b[i] = 0; 129364: c7 04 9e 00 00 00 00 movl $0x0,(%esi,%ebx,4) <== NOT EXECUTED 12936b: 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 129373: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129376: 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 ); 129378: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12937b: 56 push %esi <== NOT EXECUTED 12937c: e8 63 fd ff ff call 1290e4 <== NOT EXECUTED *block_table = 0; 129381: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 129384: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 12938a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 12938d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 129390: 5b pop %ebx <== NOT EXECUTED 129391: 5e pop %esi <== NOT EXECUTED 129392: 5f pop %edi <== NOT EXECUTED 129393: c9 leave <== NOT EXECUTED 129394: c3 ret <== NOT EXECUTED /* * Perform internal consistency checks */ assert( block_table ); 129395: 68 77 43 14 00 push $0x144377 <== NOT EXECUTED 12939a: 68 a8 44 14 00 push $0x1444a8 <== NOT EXECUTED 12939f: 68 b1 01 00 00 push $0x1b1 <== NOT EXECUTED 1293a4: 68 94 43 14 00 push $0x144394 <== NOT EXECUTED 1293a9: e8 fe 1b fe ff call 10afac <__assert_func> <== NOT EXECUTED 001297b0 : int memfile_ftruncate( rtems_libio_t *iop, off_t length ) { 1297b0: 55 push %ebp <== NOT EXECUTED 1297b1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1297b3: 53 push %ebx <== NOT EXECUTED 1297b4: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 1297b7: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1297ba: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 1297bd: 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 ) 1297c0: 39 43 50 cmp %eax,0x50(%ebx) <== NOT EXECUTED 1297c3: 7c 27 jl 1297ec <== 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; 1297c5: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED iop->size = the_jnode->info.file.size; 1297c8: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED IMFS_update_atime( the_jnode ); 1297cb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1297ce: 6a 00 push $0x0 <== NOT EXECUTED 1297d0: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1297d3: 50 push %eax <== NOT EXECUTED 1297d4: e8 13 1c fe ff call 10b3ec <== NOT EXECUTED 1297d9: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 1297dc: 89 43 40 mov %eax,0x40(%ebx) <== NOT EXECUTED 1297df: 31 c0 xor %eax,%eax <== NOT EXECUTED 1297e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 1297e4: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1297e7: c9 leave <== NOT EXECUTED 1297e8: c3 ret <== NOT EXECUTED 1297e9: 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 ); 1297ec: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1297ef: 50 push %eax <== NOT EXECUTED 1297f0: 53 push %ebx <== NOT EXECUTED 1297f1: e8 b2 fe ff ff call 1296a8 <== NOT EXECUTED 1297f6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED iop->size = the_jnode->info.file.size; IMFS_update_atime( the_jnode ); return 0; } 1297f9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1297fc: c9 leave <== NOT EXECUTED 1297fd: c3 ret <== NOT EXECUTED 001290dc : int memfile_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 1290dc: 55 push %ebp <== NOT EXECUTED 1290dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; return 0; } 1290df: 31 c0 xor %eax,%eax <== NOT EXECUTED 1290e1: c9 leave <== NOT EXECUTED 1290e2: c3 ret <== NOT EXECUTED 00129800 : off_t memfile_lseek( rtems_libio_t *iop, off_t offset, int whence ) { 129800: 55 push %ebp <== NOT EXECUTED 129801: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129803: 56 push %esi <== NOT EXECUTED 129804: 53 push %ebx <== NOT EXECUTED 129805: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 129808: 8b 5e 2c mov 0x2c(%esi),%ebx <== NOT EXECUTED if (the_jnode->type == IMFS_LINEAR_FILE) { 12980b: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) <== NOT EXECUTED 12980f: 75 13 jne 129824 <== NOT EXECUTED if (iop->offset > the_jnode->info.linearfile.size) 129811: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 129814: 39 46 08 cmp %eax,0x8(%esi) <== NOT EXECUTED 129817: 7f 27 jg 129840 <== 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; 129819: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED } 12981c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12981f: 5b pop %ebx <== NOT EXECUTED 129820: 5e pop %esi <== NOT EXECUTED 129821: c9 leave <== NOT EXECUTED 129822: c3 ret <== NOT EXECUTED 129823: 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 )) 129824: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129827: ff 76 08 pushl 0x8(%esi) <== NOT EXECUTED 12982a: 53 push %ebx <== NOT EXECUTED 12982b: e8 78 fe ff ff call 1296a8 <== NOT EXECUTED 129830: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129833: 85 c0 test %eax,%eax <== NOT EXECUTED 129835: 75 0e jne 129845 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOSPC ); iop->size = the_jnode->info.file.size; 129837: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 12983a: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 12983d: eb da jmp 129819 <== NOT EXECUTED 12983f: 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; 129840: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED 129843: eb d4 jmp 129819 <== 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 ); 129845: e8 96 75 00 00 call 130de0 <__errno> <== NOT EXECUTED 12984a: c7 00 1c 00 00 00 movl $0x1c,(%eax) <== NOT EXECUTED 129850: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 129855: eb c5 jmp 12981c <== NOT EXECUTED 00129ac8 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 129ac8: 55 push %ebp <== NOT EXECUTED 129ac9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129acb: 56 push %esi <== NOT EXECUTED 129acc: 53 push %ebx <== NOT EXECUTED 129acd: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 129ad0: 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)) 129ad3: 8b 46 0c mov 0xc(%esi),%eax <== NOT EXECUTED 129ad6: a9 04 02 00 00 test $0x204,%eax <== NOT EXECUTED 129adb: 74 06 je 129ae3 <== NOT EXECUTED 129add: 83 7b 4c 06 cmpl $0x6,0x4c(%ebx) <== NOT EXECUTED 129ae1: 74 1d je 129b00 <== 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) 129ae3: f6 c4 02 test $0x2,%ah <== NOT EXECUTED 129ae6: 75 10 jne 129af8 <== NOT EXECUTED iop->offset = the_jnode->info.file.size; iop->size = the_jnode->info.file.size; 129ae8: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 129aeb: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 129aee: 31 c0 xor %eax,%eax <== NOT EXECUTED return 0; } 129af0: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 129af3: 5b pop %ebx <== NOT EXECUTED 129af4: 5e pop %esi <== NOT EXECUTED 129af5: c9 leave <== NOT EXECUTED 129af6: c3 ret <== NOT EXECUTED 129af7: 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; 129af8: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 129afb: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED 129afe: eb e8 jmp 129ae8 <== 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; 129b00: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED const unsigned char *buffer = the_jnode->info.linearfile.direct; 129b03: 8b 53 54 mov 0x54(%ebx),%edx <== NOT EXECUTED the_jnode->type = IMFS_MEMORY_FILE; 129b06: c7 43 4c 05 00 00 00 movl $0x5,0x4c(%ebx) <== NOT EXECUTED the_jnode->info.file.size = 0; 129b0d: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED the_jnode->info.file.indirect = 0; 129b14: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED the_jnode->info.file.doubly_indirect = 0; 129b1b: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED the_jnode->info.file.triply_indirect = 0; 129b22: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED if ((count != 0) 129b29: 85 c0 test %eax,%eax <== NOT EXECUTED 129b2b: 75 0a jne 129b37 <== NOT EXECUTED 129b2d: 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) 129b30: f6 c4 02 test $0x2,%ah <== NOT EXECUTED 129b33: 74 b3 je 129ae8 <== NOT EXECUTED 129b35: eb c1 jmp 129af8 <== 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) 129b37: 50 push %eax <== NOT EXECUTED 129b38: 52 push %edx <== NOT EXECUTED 129b39: 6a 00 push $0x0 <== NOT EXECUTED 129b3b: 53 push %ebx <== NOT EXECUTED 129b3c: e8 17 fd ff ff call 129858 <== NOT EXECUTED 129b41: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 129b44: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 129b47: 75 e4 jne 129b2d <== NOT EXECUTED 129b49: eb a5 jmp 129af0 <== NOT EXECUTED 00129db4 : ssize_t memfile_read( rtems_libio_t *iop, void *buffer, size_t count ) { 129db4: 55 push %ebp <== NOT EXECUTED 129db5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129db7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 129dba: 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 ); 129dbd: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 129dc0: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 129dc3: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 129dc6: ff 70 2c pushl 0x2c(%eax) <== NOT EXECUTED 129dc9: e8 7e fd ff ff call 129b4c <== NOT EXECUTED } 129dce: c9 leave <== NOT EXECUTED 129dcf: c3 ret <== NOT EXECUTED 001295bc : */ int memfile_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 1295bc: 55 push %ebp <== NOT EXECUTED 1295bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1295bf: 53 push %ebx <== NOT EXECUTED 1295c0: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 1295c3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1295c6: 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 ) { 1295c8: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 1295cb: 85 c0 test %eax,%eax <== NOT EXECUTED 1295cd: 74 13 je 1295e2 <== NOT EXECUTED 1295cf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1295d2: 53 push %ebx <== NOT EXECUTED 1295d3: e8 24 67 fe ff call 10fcfc <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 1295d8: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED 1295df: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 1295e2: 66 ff 4b 34 decw 0x34(%ebx) <== NOT EXECUTED IMFS_update_ctime( the_jnode ); 1295e6: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1295e9: 6a 00 push $0x0 <== NOT EXECUTED 1295eb: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1295ee: 50 push %eax <== NOT EXECUTED 1295ef: e8 f8 1d fe ff call 10b3ec <== NOT EXECUTED 1295f4: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 1295f7: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED return memfile_check_rmnod( the_jnode ); 1295fa: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 1295fd: e8 5e ff ff ff call 129560 <== NOT EXECUTED } 129602: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 129605: c9 leave <== NOT EXECUTED 129606: c3 ret <== NOT EXECUTED 00129aa0 : ssize_t memfile_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 129aa0: 55 push %ebp <== NOT EXECUTED 129aa1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 129aa3: 56 push %esi <== NOT EXECUTED 129aa4: 53 push %ebx <== NOT EXECUTED 129aa5: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *the_jnode; ssize_t status; the_jnode = iop->file_info; 129aa8: 8b 73 2c mov 0x2c(%ebx),%esi <== NOT EXECUTED status = IMFS_memfile_write( the_jnode, iop->offset, buffer, count ); 129aab: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 129aae: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 129ab1: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 129ab4: 56 push %esi <== NOT EXECUTED 129ab5: e8 9e fd ff ff call 129858 <== NOT EXECUTED iop->size = the_jnode->info.file.size; 129aba: 8b 56 50 mov 0x50(%esi),%edx <== NOT EXECUTED 129abd: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED return status; } 129ac0: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 129ac3: 5b pop %ebx <== NOT EXECUTED 129ac4: 5e pop %esi <== NOT EXECUTED 129ac5: c9 leave <== NOT EXECUTED 129ac6: c3 ret <== NOT EXECUTED 0010d7e0 : */ int miniIMFS_initialize( rtems_filesystem_mount_table_entry_t *temp_mt_entry ) { 10d7e0: 55 push %ebp <== NOT EXECUTED 10d7e1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d7e3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED return IMFS_initialize_support( 10d7e6: 68 80 e7 11 00 push $0x11e780 <== NOT EXECUTED 10d7eb: 68 80 e7 11 00 push $0x11e780 <== NOT EXECUTED 10d7f0: 68 40 88 11 00 push $0x118840 <== NOT EXECUTED 10d7f5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d7f8: e8 a3 08 00 00 call 10e0a0 <== NOT EXECUTED temp_mt_entry, &miniIMFS_ops, &rtems_filesystem_null_handlers, /* for memfiles */ &rtems_filesystem_null_handlers /* for directories */ ); } 10d7fd: c9 leave <== NOT EXECUTED 10d7fe: c3 ret <== NOT EXECUTED 0010e8b8 : int mkdir( const char *pathname, mode_t mode ) { 10e8b8: 55 push %ebp <== NOT EXECUTED 10e8b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e8bb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e8be: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return mknod( pathname, mode | S_IFDIR, 0LL); 10e8c1: 6a 00 push $0x0 <== NOT EXECUTED 10e8c3: 6a 00 push $0x0 <== NOT EXECUTED 10e8c5: 80 cc 40 or $0x40,%ah <== NOT EXECUTED 10e8c8: 50 push %eax <== NOT EXECUTED 10e8c9: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10e8cc: e8 9f 8a ff ff call 107370 <== NOT EXECUTED } 10e8d1: c9 leave <== NOT EXECUTED 10e8d2: c3 ret <== NOT EXECUTED 00124c94 : int mkfifo( const char *path, mode_t mode ) { 124c94: 55 push %ebp <== NOT EXECUTED 124c95: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124c97: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124c9a: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED return mknod( path, mode | S_IFIFO, 0LL ); 124c9d: 6a 00 push $0x0 <== NOT EXECUTED 124c9f: 6a 00 push $0x0 <== NOT EXECUTED 124ca1: 80 cc 10 or $0x10,%ah <== NOT EXECUTED 124ca4: 50 push %eax <== NOT EXECUTED 124ca5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124ca8: e8 63 6d fe ff call 10ba10 <== NOT EXECUTED } 124cad: c9 leave <== NOT EXECUTED 124cae: 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 54 c8 11 00 mov 0x11c854,%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 e6 8d 00 00 call 1101b8 <__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 54 c8 11 00 mov 0x11c854,%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 4b 8d 00 00 call 1101b8 <__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 0010e8fc : const rtems_filesystem_operations_table *fs_ops, rtems_filesystem_options_t options, const char *device, const char *mount_point ) { 10e8fc: 55 push %ebp <== NOT EXECUTED 10e8fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e8ff: 57 push %edi <== NOT EXECUTED 10e900: 56 push %esi <== NOT EXECUTED 10e901: 53 push %ebx <== NOT EXECUTED 10e902: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10e905: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED /* * Is there a file system operations table? */ if ( fs_ops == NULL ) { 10e908: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e90b: 85 c0 test %eax,%eax <== NOT EXECUTED 10e90d: 0f 84 75 02 00 00 je 10eb88 <== NOT EXECUTED /* * Are the file system options valid? */ if ( options != RTEMS_FILESYSTEM_READ_ONLY && 10e913: 83 fe 01 cmp $0x1,%esi <== NOT EXECUTED 10e916: 0f 87 6c 02 00 00 ja 10eb88 <== NOT EXECUTED errno = EINVAL; return -1; } /* Do they support being mounted at all ? */ if ( !fs_ops->fsmount_me_h ) { 10e91c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10e91f: 8b 78 24 mov 0x24(%eax),%edi <== NOT EXECUTED 10e922: 85 ff test %edi,%edi <== NOT EXECUTED 10e924: 0f 84 cb 00 00 00 je 10e9f5 <== NOT EXECUTED /* * Allocate a mount table entry */ size = sizeof(rtems_filesystem_mount_table_entry_t); if ( device ) 10e92a: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED 10e92d: 85 db test %ebx,%ebx <== NOT EXECUTED 10e92f: 0f 84 ef 00 00 00 je 10ea24 <== NOT EXECUTED size += strlen( device ) + 1; 10e935: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e937: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 10e93c: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 10e93f: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 10e941: f7 d1 not %ecx <== NOT EXECUTED 10e943: 8d 41 64 lea 0x64(%ecx),%eax <== NOT EXECUTED temp_mt_entry = malloc( size ); 10e946: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e949: 50 push %eax <== NOT EXECUTED 10e94a: e8 69 89 ff ff call 1072b8 <== NOT EXECUTED 10e94f: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10e951: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED if ( !temp_mt_entry ) { 10e954: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e957: 85 c0 test %eax,%eax <== NOT EXECUTED 10e959: 0f 84 3e 02 00 00 je 10eb9d <== NOT EXECUTED errno = ENOMEM; return -1; } temp_mt_entry->mt_fs_root.mt_entry = temp_mt_entry; 10e95f: 89 43 24 mov %eax,0x24(%ebx) <== NOT EXECUTED temp_mt_entry->options = options; 10e962: 89 70 28 mov %esi,0x28(%eax) <== NOT EXECUTED if ( device ) { 10e965: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10e968: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10e96a: 0f 84 3c 01 00 00 je 10eaac <== NOT EXECUTED temp_mt_entry->dev = 10e970: 8d 40 64 lea 0x64(%eax),%eax <== NOT EXECUTED 10e973: 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 ); 10e976: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e979: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10e97c: 50 push %eax <== NOT EXECUTED 10e97d: e8 42 29 00 00 call 1112c4 <== NOT EXECUTED 10e982: 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 ) { 10e985: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 10e988: 85 d2 test %edx,%edx <== NOT EXECUTED 10e98a: 0f 84 a0 00 00 00 je 10ea30 <== NOT EXECUTED if ( rtems_filesystem_evaluate_path( 10e990: 6a 01 push $0x1 <== NOT EXECUTED 10e992: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 10e995: 56 push %esi <== NOT EXECUTED 10e996: 6a 07 push $0x7 <== NOT EXECUTED 10e998: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10e99b: e8 bc 85 ff ff call 106f5c <== NOT EXECUTED 10e9a0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e9a3: 40 inc %eax <== NOT EXECUTED 10e9a4: 74 62 je 10ea08 <== NOT EXECUTED /* * Test for node_type_h */ if (!loc.ops->node_type_h) { 10e9a6: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10e9a9: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 10e9ac: 85 c0 test %eax,%eax <== NOT EXECUTED 10e9ae: 0f 84 9c 01 00 00 je 10eb50 <== NOT EXECUTED /* * Test to see if it is a directory */ if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 10e9b4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e9b7: 56 push %esi <== NOT EXECUTED 10e9b8: ff d0 call *%eax <== NOT EXECUTED 10e9ba: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e9bd: 48 dec %eax <== NOT EXECUTED 10e9be: 0f 84 f4 00 00 00 je 10eab8 <== NOT EXECUTED errno = ENOTDIR; 10e9c4: e8 ef 17 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10e9c9: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED return 0; cleanup_and_bail: free( temp_mt_entry ); 10e9cf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e9d2: 53 push %ebx <== NOT EXECUTED 10e9d3: e8 c8 86 ff ff call 1070a0 <== NOT EXECUTED 10e9d8: 89 f7 mov %esi,%edi <== NOT EXECUTED 10e9da: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); 10e9dd: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED 10e9e0: 85 c0 test %eax,%eax <== NOT EXECUTED 10e9e2: 0f 85 78 01 00 00 jne 10eb60 <== NOT EXECUTED 10e9e8: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED return -1; } 10e9ed: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e9f0: 5b pop %ebx <== NOT EXECUTED 10e9f1: 5e pop %esi <== NOT EXECUTED 10e9f2: 5f pop %edi <== NOT EXECUTED 10e9f3: c9 leave <== NOT EXECUTED 10e9f4: c3 ret <== NOT EXECUTED return -1; } /* Do they support being mounted at all ? */ if ( !fs_ops->fsmount_me_h ) { errno = ENOTSUP; 10e9f5: e8 be 17 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10e9fa: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10ea00: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 10ea07: 90 nop <== NOT EXECUTED return 0; cleanup_and_bail: free( temp_mt_entry ); 10ea08: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ea0b: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10ea0e: e8 8d 86 ff ff call 1070a0 <== NOT EXECUTED 10ea13: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ea18: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; } 10ea1b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ea1e: 5b pop %ebx <== NOT EXECUTED 10ea1f: 5e pop %esi <== NOT EXECUTED 10ea20: 5f pop %edi <== NOT EXECUTED 10ea21: c9 leave <== NOT EXECUTED 10ea22: c3 ret <== NOT EXECUTED 10ea23: 90 nop <== NOT EXECUTED /* * Allocate a mount table entry */ size = sizeof(rtems_filesystem_mount_table_entry_t); if ( device ) 10ea24: b8 64 00 00 00 mov $0x64,%eax <== NOT EXECUTED 10ea29: e9 18 ff ff ff jmp 10e946 <== NOT EXECUTED 10ea2e: 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; 10ea30: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED temp_mt_entry->mt_fs_root.handlers = NULL; 10ea37: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) <== NOT EXECUTED temp_mt_entry->mt_fs_root.ops = NULL; 10ea3e: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.node_access = NULL; 10ea45: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.handlers = NULL; 10ea4c: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.ops = NULL; 10ea53: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.mt_entry = NULL; 10ea5a: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) <== NOT EXECUTED 10ea61: 31 ff xor %edi,%edi <== NOT EXECUTED } if ( fs_ops->fsmount_me_h( temp_mt_entry ) ) { 10ea63: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ea66: 53 push %ebx <== NOT EXECUTED 10ea67: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10ea6a: ff 52 24 call *0x24(%edx) <== NOT EXECUTED 10ea6d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ea70: 85 c0 test %eax,%eax <== NOT EXECUTED 10ea72: 0f 84 a0 00 00 00 je 10eb18 <== NOT EXECUTED /* try to undo the mount operation */ if ( loc.ops->unmount_h ) { 10ea78: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10ea7b: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 10ea7e: 85 c0 test %eax,%eax <== NOT EXECUTED 10ea80: 74 09 je 10ea8b <== NOT EXECUTED loc.ops->unmount_h( temp_mt_entry ); 10ea82: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ea85: 53 push %ebx <== NOT EXECUTED 10ea86: ff d0 call *%eax <== NOT EXECUTED 10ea88: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; cleanup_and_bail: free( temp_mt_entry ); 10ea8b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ea8e: 53 push %ebx <== NOT EXECUTED 10ea8f: e8 0c 86 ff ff call 1070a0 <== NOT EXECUTED if ( loc_to_free ) 10ea94: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ea97: 85 ff test %edi,%edi <== NOT EXECUTED 10ea99: 0f 85 3e ff ff ff jne 10e9dd <== NOT EXECUTED rtems_filesystem_freenode( loc_to_free ); 10ea9f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10eaa4: e9 44 ff ff ff jmp 10e9ed <== NOT EXECUTED 10eaa9: 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; 10eaac: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) <== NOT EXECUTED 10eab3: e9 cd fe ff ff jmp 10e985 <== NOT EXECUTED /* * For each mount table entry */ for ( the_node = rtems_filesystem_mount_table_control.first; 10eab8: a1 00 ed 11 00 mov 0x11ed00,%eax <== NOT EXECUTED !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); 10eabd: 3d 04 ed 11 00 cmp $0x11ed04,%eax <== NOT EXECUTED 10eac2: 0f 84 b6 00 00 00 je 10eb7e <== 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 ) 10eac8: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10eacb: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED 10eace: 75 09 jne 10ead9 <== NOT EXECUTED 10ead0: eb 6e jmp 10eb40 <== NOT EXECUTED 10ead2: 66 90 xchg %ax,%ax <== NOT EXECUTED 10ead4: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED 10ead7: 74 67 je 10eb40 <== 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 ) { 10ead9: 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 ); 10eadb: 3d 04 ed 11 00 cmp $0x11ed04,%eax <== NOT EXECUTED 10eae0: 75 f2 jne 10ead4 <== 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; 10eae2: 89 53 08 mov %edx,0x8(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.handlers = loc.handlers; 10eae5: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10eae8: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.ops = loc.ops; 10eaeb: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10eaee: 89 53 10 mov %edx,0x10(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry; 10eaf1: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10eaf4: 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 ){ 10eaf7: 8b 42 20 mov 0x20(%edx),%eax <== NOT EXECUTED 10eafa: 85 c0 test %eax,%eax <== NOT EXECUTED 10eafc: 74 52 je 10eb50 <== NOT EXECUTED errno = ENOTSUP; goto cleanup_and_bail; } if ( loc.ops->mount_h( temp_mt_entry ) ) { 10eafe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eb01: 53 push %ebx <== NOT EXECUTED 10eb02: ff d0 call *%eax <== NOT EXECUTED 10eb04: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eb07: 85 c0 test %eax,%eax <== NOT EXECUTED 10eb09: 0f 85 c0 fe ff ff jne 10e9cf <== NOT EXECUTED goto cleanup_and_bail; 10eb0f: 89 f7 mov %esi,%edi <== NOT EXECUTED 10eb11: e9 4d ff ff ff jmp 10ea63 <== NOT EXECUTED 10eb16: 66 90 xchg %ax,%ax <== NOT EXECUTED 10eb18: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10eb1b: 53 push %ebx <== NOT EXECUTED 10eb1c: 68 00 ed 11 00 push $0x11ed00 <== NOT EXECUTED 10eb21: e8 12 c2 ff ff call 10ad38 <_Chain_Append> <== NOT EXECUTED */ rtems_chain_append( &rtems_filesystem_mount_table_control, &temp_mt_entry->Node ); if ( mt_entry ) 10eb26: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eb29: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10eb2c: 85 c0 test %eax,%eax <== NOT EXECUTED 10eb2e: 74 05 je 10eb35 <== NOT EXECUTED *mt_entry = temp_mt_entry; 10eb30: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10eb33: 89 1f mov %ebx,(%edi) <== NOT EXECUTED 10eb35: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; } 10eb37: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10eb3a: 5b pop %ebx <== NOT EXECUTED 10eb3b: 5e pop %esi <== NOT EXECUTED 10eb3c: 5f pop %edi <== NOT EXECUTED 10eb3d: c9 leave <== NOT EXECUTED 10eb3e: c3 ret <== NOT EXECUTED 10eb3f: 90 nop <== NOT EXECUTED /* * You can only mount one file system onto a single mount point. */ if ( Is_node_fs_root( &loc ) ){ errno = EBUSY; 10eb40: e8 73 16 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10eb45: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED 10eb4b: e9 7f fe ff ff jmp 10e9cf <== 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; 10eb50: e8 63 16 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10eb55: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10eb5b: e9 6f fe ff ff jmp 10e9cf <== NOT EXECUTED cleanup_and_bail: free( temp_mt_entry ); if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); 10eb60: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10eb63: 85 c0 test %eax,%eax <== NOT EXECUTED 10eb65: 0f 84 7d fe ff ff je 10e9e8 <== NOT EXECUTED 10eb6b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eb6e: 57 push %edi <== NOT EXECUTED 10eb6f: ff d0 call *%eax <== NOT EXECUTED 10eb71: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10eb76: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eb79: e9 9d fe ff ff jmp 10ea1b <== NOT EXECUTED 10eb7e: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10eb81: e9 5c ff ff ff jmp 10eae2 <== NOT EXECUTED 10eb86: 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; 10eb88: e8 2b 16 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10eb8d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10eb93: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10eb98: e9 7e fe ff ff jmp 10ea1b <== NOT EXECUTED if ( device ) size += strlen( device ) + 1; temp_mt_entry = malloc( size ); if ( !temp_mt_entry ) { errno = ENOMEM; 10eb9d: e8 16 16 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10eba2: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10eba8: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ebad: e9 69 fe ff ff jmp 10ea1b <== 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 70 8f 00 00 call 1104a4 <== 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 bf 8d 00 00 call 110304 <== 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 50 13 12 00 00 cmpb $0x0,0x121350 <== 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 50 13 12 00 01 movb $0x1,0x121350 <== 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 f7 ab 11 00 push $0x11abf7 <== 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 90 15 12 00 mov %eax,0x121590 <== 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 5d 3f 00 00 call 10b680 <== 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 5f 6f 00 00 call 10e7c4 <== 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 c4 6f 00 00 call 10e880 <== 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 63 6e 00 00 call 10e76c <== 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 82 88 00 00 call 1101b8 <__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 70 e8 11 00 sub 0x11e870,%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 13 88 00 00 call 1101b8 <__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 eb 87 00 00 call 1101b8 <__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 70 e8 11 00 sub 0x11e870,%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 cf 6a 00 00 call 10e528 <== 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 4d 87 00 00 call 1101b8 <__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 70 e8 11 00 sub 0x11e870,%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 e8 69 00 00 call 10e490 <== 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 fc 86 00 00 call 1101b8 <__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 30 70 11 00 push $0x117030 <== 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 30 70 11 00 push $0x117030 <== 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 30 70 11 00 push $0x117030 <== 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 11 32 00 00 call 10aa40 <== 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 04 32 00 00 call 10aa40 <== NOT EXECUTED 00124d3c : * open a directory. */ DIR * opendir( const char *name ) { 124d3c: 55 push %ebp <== NOT EXECUTED 124d3d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124d3f: 56 push %esi <== NOT EXECUTED 124d40: 53 push %ebx <== NOT EXECUTED register DIR *dirp; register int fd; if ((fd = open(name, 0)) == -1) 124d41: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124d44: 6a 00 push $0x0 <== NOT EXECUTED 124d46: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124d49: e8 6e 74 fe ff call 10c1bc <== NOT EXECUTED 124d4e: 89 c6 mov %eax,%esi <== NOT EXECUTED 124d50: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124d53: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 124d56: 74 5c je 124db4 <== NOT EXECUTED return NULL; if (fcntl(fd, F_SETFD, 1) == -1 || 124d58: 50 push %eax <== NOT EXECUTED 124d59: 6a 01 push $0x1 <== NOT EXECUTED 124d5b: 6a 02 push $0x2 <== NOT EXECUTED 124d5d: 56 push %esi <== NOT EXECUTED 124d5e: e8 e5 a4 00 00 call 12f248 <== NOT EXECUTED 124d63: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124d66: 40 inc %eax <== NOT EXECUTED 124d67: 74 57 je 124dc0 <== NOT EXECUTED 124d69: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124d6c: 6a 18 push $0x18 <== NOT EXECUTED 124d6e: e8 21 6b fe ff call 10b894 <== NOT EXECUTED 124d73: 89 c3 mov %eax,%ebx <== NOT EXECUTED 124d75: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124d78: 85 c0 test %eax,%eax <== NOT EXECUTED 124d7a: 74 44 je 124dc0 <== 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); 124d7c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124d7f: 68 00 02 00 00 push $0x200 <== NOT EXECUTED 124d84: e8 0b 6b fe ff call 10b894 <== NOT EXECUTED 124d89: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED dirp->dd_len = 512; 124d8c: c7 43 10 00 02 00 00 movl $0x200,0x10(%ebx) <== NOT EXECUTED if (dirp->dd_buf == NULL) { 124d93: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124d96: 85 c0 test %eax,%eax <== NOT EXECUTED 124d98: 74 26 je 124dc0 <== NOT EXECUTED close (fd); return NULL; } dirp->dd_fd = fd; 124d9a: 89 33 mov %esi,(%ebx) <== NOT EXECUTED dirp->dd_loc = 0; 124d9c: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED dirp->dd_seek = 0; 124da3: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) <== NOT EXECUTED /* * Set up seek point for rewinddir. */ return dirp; } 124daa: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124dac: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 124daf: 5b pop %ebx <== NOT EXECUTED 124db0: 5e pop %esi <== NOT EXECUTED 124db1: c9 leave <== NOT EXECUTED 124db2: c3 ret <== NOT EXECUTED 124db3: 90 nop <== NOT EXECUTED const char *name ) { register DIR *dirp; register int fd; if ((fd = open(name, 0)) == -1) 124db4: 31 db xor %ebx,%ebx <== NOT EXECUTED dirp->dd_seek = 0; /* * Set up seek point for rewinddir. */ return dirp; } 124db6: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124db8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 124dbb: 5b pop %ebx <== NOT EXECUTED 124dbc: 5e pop %esi <== NOT EXECUTED 124dbd: c9 leave <== NOT EXECUTED 124dbe: c3 ret <== NOT EXECUTED 124dbf: 90 nop <== NOT EXECUTED */ dirp->dd_buf = malloc (512); dirp->dd_len = 512; if (dirp->dd_buf == NULL) { close (fd); 124dc0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124dc3: 56 push %esi <== NOT EXECUTED 124dc4: e8 33 63 fe ff call 10b0fc <== NOT EXECUTED 124dc9: 31 db xor %ebx,%ebx <== NOT EXECUTED 124dcb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED dirp->dd_seek = 0; /* * Set up seek point for rewinddir. */ return dirp; } 124dce: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124dd0: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 124dd3: 5b pop %ebx <== NOT EXECUTED 124dd4: 5e pop %esi <== NOT EXECUTED 124dd5: c9 leave <== NOT EXECUTED 124dd6: 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 b4 c8 11 00 mov 0x11c8b4,%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 f8 84 11 00 push $0x1184f8 <== 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 b4 c8 11 00 mov 0x11c8b4,%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 fa 84 11 00 push $0x1184fa <== 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 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 08 3b 12 00 incl 0x123b08 <== 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 00116724 : ssize_t read( int fd, void *buffer, size_t count ) { 116724: 55 push %ebp <== NOT EXECUTED 116725: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116727: 56 push %esi <== NOT EXECUTED 116728: 53 push %ebx <== NOT EXECUTED 116729: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 11672c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11672f: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 116732: 3b 15 e0 a3 11 00 cmp 0x11a3e0,%edx <== NOT EXECUTED 116738: 73 56 jae 116790 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 11673a: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 11673d: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 116740: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 116747: 03 1d 70 e8 11 00 add 0x11e870,%ebx <== NOT EXECUTED rtems_libio_check_is_open( iop ); 11674d: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 116750: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 116753: 74 3b je 116790 <== NOT EXECUTED rtems_libio_check_buffer( buffer ); 116755: 85 f6 test %esi,%esi <== NOT EXECUTED 116757: 74 4b je 1167a4 <== NOT EXECUTED rtems_libio_check_count( count ); 116759: 85 c9 test %ecx,%ecx <== NOT EXECUTED 11675b: 74 27 je 116784 <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_READ ); 11675d: a8 02 test $0x2,%al <== NOT EXECUTED 11675f: 74 43 je 1167a4 <== NOT EXECUTED /* * Now process the read(). */ if ( !iop->handlers->read_h ) 116761: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 116764: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 116767: 85 c0 test %eax,%eax <== NOT EXECUTED 116769: 74 4b je 1167b6 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); rc = (*iop->handlers->read_h)( iop, buffer, count ); 11676b: 52 push %edx <== NOT EXECUTED 11676c: 51 push %ecx <== NOT EXECUTED 11676d: 56 push %esi <== NOT EXECUTED 11676e: 53 push %ebx <== NOT EXECUTED 11676f: ff d0 call *%eax <== NOT EXECUTED if ( rc > 0 ) 116771: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116774: 85 c0 test %eax,%eax <== NOT EXECUTED 116776: 7e 03 jle 11677b <== NOT EXECUTED iop->offset += rc; 116778: 01 43 08 add %eax,0x8(%ebx) <== NOT EXECUTED return rc; } 11677b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11677e: 5b pop %ebx <== NOT EXECUTED 11677f: 5e pop %esi <== NOT EXECUTED 116780: c9 leave <== NOT EXECUTED 116781: c3 ret <== NOT EXECUTED 116782: 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 ); 116784: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( rc > 0 ) iop->offset += rc; return rc; } 116786: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 116789: 5b pop %ebx <== NOT EXECUTED 11678a: 5e pop %esi <== NOT EXECUTED 11678b: c9 leave <== NOT EXECUTED 11678c: c3 ret <== NOT EXECUTED 11678d: 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 ); 116790: e8 23 9a ff ff call 1101b8 <__errno> <== NOT EXECUTED 116795: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 11679b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1167a0: eb d9 jmp 11677b <== NOT EXECUTED 1167a2: 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 ); 1167a4: e8 0f 9a ff ff call 1101b8 <__errno> <== NOT EXECUTED 1167a9: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1167af: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1167b4: eb c5 jmp 11677b <== NOT EXECUTED /* * Now process the read(). */ if ( !iop->handlers->read_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 1167b6: e8 fd 99 ff ff call 1101b8 <__errno> <== NOT EXECUTED 1167bb: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1167c1: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1167c6: eb b3 jmp 11677b <== NOT EXECUTED 00124fe4 : /* * get next entry in a directory. */ struct dirent * readdir( DIR *dirp ) { 124fe4: 55 push %ebp <== NOT EXECUTED 124fe5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124fe7: 56 push %esi <== NOT EXECUTED 124fe8: 53 push %ebx <== NOT EXECUTED 124fe9: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED register struct dirent *dp; if ( !dirp ) 124fec: 85 db test %ebx,%ebx <== NOT EXECUTED 124fee: 75 0b jne 124ffb <== NOT EXECUTED 124ff0: eb 67 jmp 125059 <== NOT EXECUTED 124ff2: 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; 124ff4: c7 43 04 00 00 00 00 movl $0x0,0x4(%ebx) <== NOT EXECUTED if ( !dirp ) return NULL; for (;;) { if (dirp->dd_loc == 0) { 124ffb: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 124ffe: 85 d2 test %edx,%edx <== NOT EXECUTED 125000: 74 3a je 12503c <== NOT EXECUTED dirp->dd_len); if (dirp->dd_size <= 0) return NULL; } if (dirp->dd_loc >= dirp->dd_size) { 125002: 39 53 08 cmp %edx,0x8(%ebx) <== NOT EXECUTED 125005: 7e ed jle 124ff4 <== NOT EXECUTED dirp->dd_loc = 0; continue; } dp = (struct dirent *)(dirp->dd_buf + dirp->dd_loc); 125007: 89 d1 mov %edx,%ecx <== NOT EXECUTED 125009: 03 4b 0c add 0xc(%ebx),%ecx <== NOT EXECUTED if ((intptr_t)dp & 03) /* bogus pointer check */ 12500c: f6 c1 03 test $0x3,%cl <== NOT EXECUTED 12500f: 75 48 jne 125059 <== NOT EXECUTED return NULL; if (dp->d_reclen <= 0 || 125011: 8b 41 08 mov 0x8(%ecx),%eax <== NOT EXECUTED 125014: 66 85 c0 test %ax,%ax <== NOT EXECUTED 125017: 74 40 je 125059 <== NOT EXECUTED 125019: 0f b7 f0 movzwl %ax,%esi <== NOT EXECUTED 12501c: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 12501f: 40 inc %eax <== NOT EXECUTED 125020: 29 d0 sub %edx,%eax <== NOT EXECUTED 125022: 39 c6 cmp %eax,%esi <== NOT EXECUTED 125024: 7f 33 jg 125059 <== NOT EXECUTED dp->d_reclen > dirp->dd_len + 1 - dirp->dd_loc) return NULL; dirp->dd_loc += dp->d_reclen; 125026: 8d 04 32 lea (%edx,%esi,1),%eax <== NOT EXECUTED 125029: 89 43 04 mov %eax,0x4(%ebx) <== NOT EXECUTED if (dp->d_ino == 0) 12502c: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 12502e: 85 c0 test %eax,%eax <== NOT EXECUTED 125030: 74 c9 je 124ffb <== NOT EXECUTED continue; return (dp); } } 125032: 89 c8 mov %ecx,%eax <== NOT EXECUTED 125034: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 125037: 5b pop %ebx <== NOT EXECUTED 125038: 5e pop %esi <== NOT EXECUTED 125039: c9 leave <== NOT EXECUTED 12503a: c3 ret <== NOT EXECUTED 12503b: 90 nop <== NOT EXECUTED if ( !dirp ) return NULL; for (;;) { if (dirp->dd_loc == 0) { dirp->dd_size = getdents (dirp->dd_fd, 12503c: 52 push %edx <== NOT EXECUTED 12503d: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 125040: ff 73 0c pushl 0xc(%ebx) <== NOT EXECUTED 125043: ff 33 pushl (%ebx) <== NOT EXECUTED 125045: e8 ee a3 00 00 call 12f438 <== NOT EXECUTED 12504a: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED dirp->dd_buf, dirp->dd_len); if (dirp->dd_size <= 0) 12504d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125050: 85 c0 test %eax,%eax <== NOT EXECUTED 125052: 7e 05 jle 125059 <== NOT EXECUTED 125054: 8b 53 04 mov 0x4(%ebx),%edx <== NOT EXECUTED 125057: eb a9 jmp 125002 <== 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) 125059: 31 c9 xor %ecx,%ecx <== NOT EXECUTED continue; return (dp); } } 12505b: 89 c8 mov %ecx,%eax <== NOT EXECUTED 12505d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 125060: 5b pop %ebx <== NOT EXECUTED 125061: 5e pop %esi <== NOT EXECUTED 125062: c9 leave <== NOT EXECUTED 125063: c3 ret <== NOT EXECUTED 00125064 : ssize_t readlink( const char *pathname, char *buf, size_t bufsize ) { 125064: 55 push %ebp <== NOT EXECUTED 125065: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125067: 56 push %esi <== NOT EXECUTED 125068: 53 push %ebx <== NOT EXECUTED 125069: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 12506c: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED rtems_filesystem_location_info_t loc; int result; if (!buf) 12506f: 85 db test %ebx,%ebx <== NOT EXECUTED 125071: 0f 84 99 00 00 00 je 125110 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EFAULT ); result = rtems_filesystem_evaluate_path( pathname, 0, &loc, false ); 125077: 6a 00 push $0x0 <== NOT EXECUTED 125079: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 12507c: 56 push %esi <== NOT EXECUTED 12507d: 6a 00 push $0x0 <== NOT EXECUTED 12507f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125082: e8 a5 61 fe ff call 10b22c <== NOT EXECUTED if ( result != 0 ) 125087: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12508a: 85 c0 test %eax,%eax <== NOT EXECUTED 12508c: 75 72 jne 125100 <== NOT EXECUTED return -1; if ( !loc.ops->node_type_h ){ 12508e: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 125091: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 125094: 85 c0 test %eax,%eax <== NOT EXECUTED 125096: 74 4d je 1250e5 <== 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 ){ 125098: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12509b: 56 push %esi <== NOT EXECUTED 12509c: ff d0 call *%eax <== NOT EXECUTED 12509e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1250a1: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 1250a4: 0f 85 82 00 00 00 jne 12512c <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( EINVAL ); } if ( !loc.ops->readlink_h ){ 1250aa: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1250ad: 8b 50 3c mov 0x3c(%eax),%edx <== NOT EXECUTED 1250b0: 85 d2 test %edx,%edx <== NOT EXECUTED 1250b2: 0f 84 9d 00 00 00 je 125155 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); 1250b8: 50 push %eax <== NOT EXECUTED 1250b9: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 1250bc: 53 push %ebx <== NOT EXECUTED 1250bd: 56 push %esi <== NOT EXECUTED 1250be: ff d2 call *%edx <== NOT EXECUTED 1250c0: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1250c2: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1250c5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1250c8: 85 c0 test %eax,%eax <== NOT EXECUTED 1250ca: 74 10 je 1250dc <== NOT EXECUTED 1250cc: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1250cf: 85 c0 test %eax,%eax <== NOT EXECUTED 1250d1: 74 09 je 1250dc <== NOT EXECUTED 1250d3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1250d6: 56 push %esi <== NOT EXECUTED 1250d7: ff d0 call *%eax <== NOT EXECUTED 1250d9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 1250dc: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1250de: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1250e1: 5b pop %ebx <== NOT EXECUTED 1250e2: 5e pop %esi <== NOT EXECUTED 1250e3: c9 leave <== NOT EXECUTED 1250e4: 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 ); 1250e5: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 1250e8: 85 c0 test %eax,%eax <== NOT EXECUTED 1250ea: 74 09 je 1250f5 <== NOT EXECUTED 1250ec: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1250ef: 56 push %esi <== NOT EXECUTED 1250f0: ff d0 call *%eax <== NOT EXECUTED 1250f2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 1250f5: e8 e6 bc 00 00 call 130de0 <__errno> <== NOT EXECUTED 1250fa: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 125100: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); rtems_filesystem_freenode( &loc ); return result; } 125105: 89 d8 mov %ebx,%eax <== NOT EXECUTED 125107: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12510a: 5b pop %ebx <== NOT EXECUTED 12510b: 5e pop %esi <== NOT EXECUTED 12510c: c9 leave <== NOT EXECUTED 12510d: c3 ret <== NOT EXECUTED 12510e: 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 ); 125110: e8 cb bc 00 00 call 130de0 <__errno> <== NOT EXECUTED 125115: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 12511b: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED result = (*loc.ops->readlink_h)( &loc, buf, bufsize ); rtems_filesystem_freenode( &loc ); return result; } 125120: 89 d8 mov %ebx,%eax <== NOT EXECUTED 125122: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 125125: 5b pop %ebx <== NOT EXECUTED 125126: 5e pop %esi <== NOT EXECUTED 125127: c9 leave <== NOT EXECUTED 125128: c3 ret <== NOT EXECUTED 125129: 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 ); 12512c: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 12512f: 85 c0 test %eax,%eax <== NOT EXECUTED 125131: 74 10 je 125143 <== NOT EXECUTED 125133: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 125136: 85 c0 test %eax,%eax <== NOT EXECUTED 125138: 74 09 je 125143 <== NOT EXECUTED 12513a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12513d: 56 push %esi <== NOT EXECUTED 12513e: ff d0 call *%eax <== NOT EXECUTED 125140: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EINVAL ); 125143: e8 98 bc 00 00 call 130de0 <__errno> <== NOT EXECUTED 125148: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 12514e: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 125153: eb 87 jmp 1250dc <== NOT EXECUTED } if ( !loc.ops->readlink_h ){ rtems_filesystem_freenode( &loc ); 125155: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 125158: 85 c0 test %eax,%eax <== NOT EXECUTED 12515a: 74 09 je 125165 <== NOT EXECUTED 12515c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12515f: 56 push %esi <== NOT EXECUTED 125160: ff d0 call *%eax <== NOT EXECUTED 125162: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 125165: e8 76 bc 00 00 call 130de0 <__errno> <== NOT EXECUTED 12516a: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 125170: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 125175: e9 62 ff ff ff jmp 1250dc <== NOT EXECUTED 00116848 : { size_t old_size; char *new_area; size_t resize; MSBUMP(realloc_calls, 1); 116848: 55 push %ebp <== NOT EXECUTED 116849: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11684b: 57 push %edi <== NOT EXECUTED 11684c: 56 push %esi <== NOT EXECUTED 11684d: 53 push %ebx <== NOT EXECUTED 11684e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 116851: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 116854: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 116857: ff 05 10 e9 11 00 incl 0x11e910 <== NOT EXECUTED /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 11685d: 83 3d c4 eb 11 00 03 cmpl $0x3,0x11ebc4 <== NOT EXECUTED 116864: 74 6e je 1168d4 <== NOT EXECUTED } /* * Continue with realloc(). */ if ( !ptr ) 116866: 85 db test %ebx,%ebx <== NOT EXECUTED 116868: 74 3a je 1168a4 <== NOT EXECUTED return malloc( size ); if ( !size ) { 11686a: 85 f6 test %esi,%esi <== NOT EXECUTED 11686c: 74 46 je 1168b4 <== NOT EXECUTED free( ptr ); return (void *) 0; } if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) { 11686e: 52 push %edx <== NOT EXECUTED 11686f: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 116872: 50 push %eax <== NOT EXECUTED 116873: 53 push %ebx <== NOT EXECUTED 116874: 68 a0 e8 11 00 push $0x11e8a0 <== NOT EXECUTED 116879: e8 5a 01 00 00 call 1169d8 <_Protected_heap_Get_block_size> <== NOT EXECUTED 11687e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116881: 84 c0 test %al,%al <== NOT EXECUTED 116883: 74 3f je 1168c4 <== 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 ) ) { 116885: 50 push %eax <== NOT EXECUTED 116886: 56 push %esi <== NOT EXECUTED 116887: 53 push %ebx <== NOT EXECUTED 116888: 68 a0 e8 11 00 push $0x11e8a0 <== NOT EXECUTED 11688d: e8 7e 01 00 00 call 116a10 <_Protected_heap_Resize_block> <== NOT EXECUTED 116892: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116895: 84 c0 test %al,%al <== NOT EXECUTED 116897: 74 5b je 1168f4 <== NOT EXECUTED memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; } 116899: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11689b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11689e: 5b pop %ebx <== NOT EXECUTED 11689f: 5e pop %esi <== NOT EXECUTED 1168a0: 5f pop %edi <== NOT EXECUTED 1168a1: c9 leave <== NOT EXECUTED 1168a2: c3 ret <== NOT EXECUTED 1168a3: 90 nop <== NOT EXECUTED /* * Continue with realloc(). */ if ( !ptr ) return malloc( size ); 1168a4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1168a7: 56 push %esi <== NOT EXECUTED 1168a8: e8 0b 0a ff ff call 1072b8 <== NOT EXECUTED 1168ad: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1168af: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1168b2: eb e5 jmp 116899 <== NOT EXECUTED if ( !size ) { free( ptr ); 1168b4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1168b7: 53 push %ebx <== NOT EXECUTED 1168b8: e8 e3 07 ff ff call 1070a0 <== NOT EXECUTED 1168bd: 31 db xor %ebx,%ebx <== NOT EXECUTED 1168bf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1168c2: eb d5 jmp 116899 <== NOT EXECUTED return (void *) 0; } if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) { errno = EINVAL; 1168c4: e8 ef 98 ff ff call 1101b8 <__errno> <== NOT EXECUTED 1168c9: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1168cf: 31 db xor %ebx,%ebx <== NOT EXECUTED 1168d1: eb c6 jmp 116899 <== NOT EXECUTED 1168d3: 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) 1168d4: a1 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 1168d9: 85 c0 test %eax,%eax <== NOT EXECUTED 1168db: 74 04 je 1168e1 <== NOT EXECUTED } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; 1168dd: 31 db xor %ebx,%ebx <== NOT EXECUTED 1168df: eb b8 jmp 116899 <== NOT EXECUTED if (_System_state_Is_up(_System_state_Get())) { if (_Thread_Dispatch_disable_level > 0) return (void *) 0; if (_ISR_Nest_level > 0) 1168e1: a1 98 ea 11 00 mov 0x11ea98,%eax <== NOT EXECUTED 1168e6: 85 c0 test %eax,%eax <== NOT EXECUTED 1168e8: 0f 84 78 ff ff ff je 116866 <== NOT EXECUTED } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; 1168ee: 31 db xor %ebx,%ebx <== NOT EXECUTED 1168f0: eb a7 jmp 116899 <== NOT EXECUTED 1168f2: 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 ); 1168f4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1168f7: 56 push %esi <== NOT EXECUTED 1168f8: e8 bb 09 ff ff call 1072b8 <== NOT EXECUTED 1168fd: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED MSBUMP(malloc_calls, -1); /* subtract off the malloc */ 116900: ff 0d 04 e9 11 00 decl 0x11e904 <== NOT EXECUTED if ( !new_area ) { 116906: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116909: 85 c0 test %eax,%eax <== NOT EXECUTED 11690b: 74 d0 je 1168dd <== NOT EXECUTED return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 11690d: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 116910: 89 f1 mov %esi,%ecx <== NOT EXECUTED 116912: 39 c6 cmp %eax,%esi <== NOT EXECUTED 116914: 76 02 jbe 116918 <== NOT EXECUTED 116916: 89 c1 mov %eax,%ecx <== NOT EXECUTED 116918: 8b 7d dc mov -0x24(%ebp),%edi <== NOT EXECUTED 11691b: 89 de mov %ebx,%esi <== NOT EXECUTED 11691d: f3 a4 rep movsb %ds:(%esi),%es:(%edi) <== NOT EXECUTED free( ptr ); 11691f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116922: 53 push %ebx <== NOT EXECUTED 116923: e8 78 07 ff ff call 1070a0 <== NOT EXECUTED 116928: 8b 5d dc mov -0x24(%ebp),%ebx <== NOT EXECUTED 11692b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11692e: e9 66 ff ff ff jmp 116899 <== NOT EXECUTED 0012517c : #include int rmdir( const char *pathname ) { 12517c: 55 push %ebp <== NOT EXECUTED 12517d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12517f: 56 push %esi <== NOT EXECUTED 125180: 53 push %ebx <== NOT EXECUTED 125181: 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 ); 125184: 6a 00 push $0x0 <== NOT EXECUTED 125186: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 125189: 56 push %esi <== NOT EXECUTED 12518a: 6a 00 push $0x0 <== NOT EXECUTED 12518c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12518f: e8 98 60 fe ff call 10b22c <== NOT EXECUTED if ( result != 0 ) 125194: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125197: 85 c0 test %eax,%eax <== NOT EXECUTED 125199: 74 11 je 1251ac <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.handlers->rmnod_h)( &loc ); rtems_filesystem_freenode( &loc ); 12519b: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED return result; } 1251a0: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1251a2: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1251a5: 5b pop %ebx <== NOT EXECUTED 1251a6: 5e pop %esi <== NOT EXECUTED 1251a7: c9 leave <== NOT EXECUTED 1251a8: c3 ret <== NOT EXECUTED 1251a9: 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 ); 1251ac: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1251af: 56 push %esi <== NOT EXECUTED 1251b0: 6a 02 push $0x2 <== NOT EXECUTED 1251b2: e8 dd 5f fe ff call 10b194 <== NOT EXECUTED if (result != 0) { 1251b7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1251ba: 85 c0 test %eax,%eax <== NOT EXECUTED 1251bc: 0f 85 82 00 00 00 jne 125244 <== NOT EXECUTED /* * Verify you can remove this node as a directory. */ if ( !loc.ops->node_type_h ){ 1251c2: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 1251c5: 8b 42 10 mov 0x10(%edx),%eax <== NOT EXECUTED 1251c8: 85 c0 test %eax,%eax <== NOT EXECUTED 1251ca: 0f 84 a0 00 00 00 je 125270 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ){ 1251d0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1251d3: 56 push %esi <== NOT EXECUTED 1251d4: ff d0 call *%eax <== NOT EXECUTED 1251d6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1251d9: 48 dec %eax <== NOT EXECUTED 1251da: 75 3c jne 125218 <== NOT EXECUTED /* * Use the filesystems rmnod to remove the node. */ if ( !loc.handlers->rmnod_h ){ 1251dc: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1251df: 8b 40 34 mov 0x34(%eax),%eax <== NOT EXECUTED 1251e2: 85 c0 test %eax,%eax <== NOT EXECUTED 1251e4: 0f 84 ab 00 00 00 je 125295 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.handlers->rmnod_h)( &loc ); 1251ea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1251ed: 56 push %esi <== NOT EXECUTED 1251ee: ff d0 call *%eax <== NOT EXECUTED 1251f0: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 1251f2: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1251f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1251f8: 85 c0 test %eax,%eax <== NOT EXECUTED 1251fa: 74 a4 je 1251a0 <== NOT EXECUTED 1251fc: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1251ff: 85 c0 test %eax,%eax <== NOT EXECUTED 125201: 74 9d je 1251a0 <== NOT EXECUTED 125203: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125206: 56 push %esi <== NOT EXECUTED 125207: ff d0 call *%eax <== NOT EXECUTED 125209: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 12520c: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12520e: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 125211: 5b pop %ebx <== NOT EXECUTED 125212: 5e pop %esi <== NOT EXECUTED 125213: c9 leave <== NOT EXECUTED 125214: c3 ret <== NOT EXECUTED 125215: 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 ); 125218: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 12521b: 85 c0 test %eax,%eax <== NOT EXECUTED 12521d: 74 10 je 12522f <== NOT EXECUTED 12521f: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 125222: 85 c0 test %eax,%eax <== NOT EXECUTED 125224: 74 09 je 12522f <== NOT EXECUTED 125226: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125229: 56 push %esi <== NOT EXECUTED 12522a: ff d0 call *%eax <== NOT EXECUTED 12522c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTDIR ); 12522f: e8 ac bb 00 00 call 130de0 <__errno> <== NOT EXECUTED 125234: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 12523a: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 12523f: e9 5c ff ff ff jmp 1251a0 <== NOT EXECUTED if ( result != 0 ) return -1; result = rtems_filesystem_evaluate_parent(RTEMS_LIBIO_PERMS_WRITE, &loc ); if (result != 0) { rtems_filesystem_freenode( &loc ); 125244: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 125247: 85 c0 test %eax,%eax <== NOT EXECUTED 125249: 0f 84 4c ff ff ff je 12519b <== NOT EXECUTED 12524f: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 125252: 85 c0 test %eax,%eax <== NOT EXECUTED 125254: 0f 84 41 ff ff ff je 12519b <== NOT EXECUTED 12525a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12525d: 56 push %esi <== NOT EXECUTED 12525e: ff d0 call *%eax <== NOT EXECUTED 125260: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 125265: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125268: e9 33 ff ff ff jmp 1251a0 <== NOT EXECUTED 12526d: 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 ); 125270: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 125273: 85 c0 test %eax,%eax <== NOT EXECUTED 125275: 74 09 je 125280 <== NOT EXECUTED /* * Use the filesystems rmnod to remove the node. */ if ( !loc.handlers->rmnod_h ){ rtems_filesystem_freenode( &loc ); 125277: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12527a: 56 push %esi <== NOT EXECUTED 12527b: ff d0 call *%eax <== NOT EXECUTED 12527d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 125280: e8 5b bb 00 00 call 130de0 <__errno> <== NOT EXECUTED 125285: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 12528b: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 125290: e9 0b ff ff ff jmp 1251a0 <== NOT EXECUTED /* * Use the filesystems rmnod to remove the node. */ if ( !loc.handlers->rmnod_h ){ rtems_filesystem_freenode( &loc ); 125295: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 125298: 85 c0 test %eax,%eax <== NOT EXECUTED 12529a: 74 e4 je 125280 <== NOT EXECUTED 12529c: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12529f: 85 c0 test %eax,%eax <== NOT EXECUTED 1252a1: 75 d4 jne 125277 <== NOT EXECUTED 1252a3: eb db jmp 125280 <== NOT EXECUTED 0010fc40 : uint32_t rtems_assoc_local_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10fc40: 55 push %ebp <== NOT EXECUTED 10fc41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fc43: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_remote(ap, remote_value); 10fc46: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10fc49: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10fc4c: e8 0f 00 00 00 call 10fc60 <== NOT EXECUTED if (nap) 10fc51: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fc54: 85 c0 test %eax,%eax <== NOT EXECUTED 10fc56: 74 03 je 10fc5b <== NOT EXECUTED return nap->local_value; 10fc58: 8b 40 04 mov 0x4(%eax),%eax <== NOT EXECUTED return 0; } 10fc5b: c9 leave <== NOT EXECUTED 10fc5c: c3 ret <== NOT EXECUTED 0010fbfc : uint32_t rtems_assoc_local_by_remote_bitfield( const rtems_assoc_t *ap, uint32_t remote_value ) { 10fbfc: 55 push %ebp <== NOT EXECUTED 10fbfd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fbff: 57 push %edi <== NOT EXECUTED 10fc00: 56 push %esi <== NOT EXECUTED 10fc01: 53 push %ebx <== NOT EXECUTED 10fc02: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fc05: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 10fc0a: 31 ff xor %edi,%edi <== NOT EXECUTED 10fc0c: 31 db xor %ebx,%ebx <== NOT EXECUTED 10fc0e: eb 08 jmp 10fc18 <== NOT EXECUTED uint32_t b; uint32_t local_value = 0; for (b = 1; b; b <<= 1) { 10fc10: d1 e6 shl %esi <== NOT EXECUTED 10fc12: 43 inc %ebx <== NOT EXECUTED 10fc13: 83 fb 20 cmp $0x20,%ebx <== NOT EXECUTED 10fc16: 74 1e je 10fc36 <== NOT EXECUTED if (b & remote_value) 10fc18: 85 75 0c test %esi,0xc(%ebp) <== NOT EXECUTED 10fc1b: 74 f3 je 10fc10 <== NOT EXECUTED local_value |= rtems_assoc_local_by_remote(ap, b); 10fc1d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10fc20: 56 push %esi <== NOT EXECUTED 10fc21: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10fc24: e8 17 00 00 00 call 10fc40 <== NOT EXECUTED 10fc29: 09 c7 or %eax,%edi <== NOT EXECUTED 10fc2b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { uint32_t b; uint32_t local_value = 0; for (b = 1; b; b <<= 1) { 10fc2e: d1 e6 shl %esi <== NOT EXECUTED 10fc30: 43 inc %ebx <== NOT EXECUTED 10fc31: 83 fb 20 cmp $0x20,%ebx <== NOT EXECUTED 10fc34: 75 e2 jne 10fc18 <== NOT EXECUTED if (b & remote_value) local_value |= rtems_assoc_local_by_remote(ap, b); } return local_value; } 10fc36: 89 f8 mov %edi,%eax <== NOT EXECUTED 10fc38: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10fc3b: 5b pop %ebx <== NOT EXECUTED 10fc3c: 5e pop %esi <== NOT EXECUTED 10fc3d: 5f pop %edi <== NOT EXECUTED 10fc3e: c9 leave <== NOT EXECUTED 10fc3f: c3 ret <== NOT EXECUTED 00118554 : const char * rtems_assoc_name_bad( uint32_t bad_value ) { 118554: 55 push %ebp <== NOT EXECUTED 118555: 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; } 118557: b8 60 a1 12 00 mov $0x12a160,%eax <== NOT EXECUTED 11855c: c9 leave <== NOT EXECUTED 11855d: c3 ret <== NOT EXECUTED 00114ce0 : const char *rtems_assoc_name_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 114ce0: 55 push %ebp <== NOT EXECUTED 114ce1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 114ce3: 53 push %ebx <== NOT EXECUTED 114ce4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114ce7: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 114cea: 53 push %ebx <== NOT EXECUTED 114ceb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114cee: e8 1d 00 00 00 call 114d10 <== NOT EXECUTED if (nap) 114cf3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114cf6: 85 c0 test %eax,%eax <== NOT EXECUTED 114cf8: 74 0a je 114d04 <== NOT EXECUTED return nap->name; 114cfa: 8b 00 mov (%eax),%eax <== NOT EXECUTED return rtems_assoc_name_bad(local_value); } 114cfc: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114cff: c9 leave <== NOT EXECUTED 114d00: c3 ret <== NOT EXECUTED 114d01: 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); 114d04: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 114d07: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 114d0a: 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); 114d0b: e9 44 38 00 00 jmp 118554 <== NOT EXECUTED 00110138 : const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 110138: 55 push %ebp <== NOT EXECUTED 110139: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11013b: 57 push %edi <== NOT EXECUTED 11013c: 56 push %esi <== NOT EXECUTED 11013d: 53 push %ebx <== NOT EXECUTED 11013e: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 110141: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 110144: 8b 33 mov (%ebx),%esi <== NOT EXECUTED 110146: 85 f6 test %esi,%esi <== NOT EXECUTED 110148: 74 4a je 110194 <== NOT EXECUTED 11014a: bf 09 8c 11 00 mov $0x118c09,%edi <== NOT EXECUTED 11014f: b9 0a 00 00 00 mov $0xa,%ecx <== NOT EXECUTED 110154: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 110156: 74 20 je 110178 <== NOT EXECUTED 110158: 31 d2 xor %edx,%edx <== NOT EXECUTED 11015a: eb 09 jmp 110165 <== NOT EXECUTED default_ap = ap++; for ( ; ap->name; ap++) 11015c: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 11015f: 8b 0b mov (%ebx),%ecx <== NOT EXECUTED 110161: 85 c9 test %ecx,%ecx <== NOT EXECUTED 110163: 74 23 je 110188 <== NOT EXECUTED if (ap->local_value == local_value) 110165: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 110168: 39 43 04 cmp %eax,0x4(%ebx) <== NOT EXECUTED 11016b: 75 ef jne 11015c <== NOT EXECUTED return ap; return default_ap; } 11016d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11016f: 5a pop %edx <== NOT EXECUTED 110170: 5b pop %ebx <== NOT EXECUTED 110171: 5e pop %esi <== NOT EXECUTED 110172: 5f pop %edi <== NOT EXECUTED 110173: c9 leave <== NOT EXECUTED 110174: c3 ret <== NOT EXECUTED 110175: 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++; 110178: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED for ( ; ap->name; ap++) 11017b: 8b 73 0c mov 0xc(%ebx),%esi <== NOT EXECUTED 11017e: 85 f6 test %esi,%esi <== NOT EXECUTED 110180: 74 eb je 11016d <== NOT EXECUTED 110182: 89 da mov %ebx,%edx <== NOT EXECUTED 110184: 89 c3 mov %eax,%ebx <== NOT EXECUTED 110186: eb dd jmp 110165 <== NOT EXECUTED 110188: 89 d3 mov %edx,%ebx <== NOT EXECUTED if (ap->local_value == local_value) return ap; return default_ap; } 11018a: 89 d8 mov %ebx,%eax <== NOT EXECUTED 11018c: 5a pop %edx <== NOT EXECUTED 11018d: 5b pop %ebx <== NOT EXECUTED 11018e: 5e pop %esi <== NOT EXECUTED 11018f: 5f pop %edi <== NOT EXECUTED 110190: c9 leave <== NOT EXECUTED 110191: c3 ret <== NOT EXECUTED 110192: 66 90 xchg %ax,%ax <== NOT EXECUTED uint32_t local_value ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 110194: 31 db xor %ebx,%ebx <== NOT EXECUTED for ( ; ap->name; ap++) if (ap->local_value == local_value) return ap; return default_ap; } 110196: 89 d8 mov %ebx,%eax <== NOT EXECUTED 110198: 5a pop %edx <== NOT EXECUTED 110199: 5b pop %ebx <== NOT EXECUTED 11019a: 5e pop %esi <== NOT EXECUTED 11019b: 5f pop %edi <== NOT EXECUTED 11019c: c9 leave <== NOT EXECUTED 11019d: c3 ret <== NOT EXECUTED 0010fc60 : const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10fc60: 55 push %ebp <== NOT EXECUTED 10fc61: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fc63: 57 push %edi <== NOT EXECUTED 10fc64: 56 push %esi <== NOT EXECUTED 10fc65: 53 push %ebx <== NOT EXECUTED 10fc66: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10fc69: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 10fc6c: 8b 33 mov (%ebx),%esi <== NOT EXECUTED 10fc6e: 85 f6 test %esi,%esi <== NOT EXECUTED 10fc70: 74 4a je 10fcbc <== NOT EXECUTED 10fc72: bf 09 8c 11 00 mov $0x118c09,%edi <== NOT EXECUTED 10fc77: b9 0a 00 00 00 mov $0xa,%ecx <== NOT EXECUTED 10fc7c: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 10fc7e: 74 20 je 10fca0 <== NOT EXECUTED 10fc80: 31 d2 xor %edx,%edx <== NOT EXECUTED 10fc82: eb 09 jmp 10fc8d <== NOT EXECUTED default_ap = ap++; for ( ; ap->name; ap++) 10fc84: 83 c3 0c add $0xc,%ebx <== NOT EXECUTED 10fc87: 8b 0b mov (%ebx),%ecx <== NOT EXECUTED 10fc89: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10fc8b: 74 23 je 10fcb0 <== NOT EXECUTED if (ap->remote_value == remote_value) 10fc8d: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10fc90: 39 43 08 cmp %eax,0x8(%ebx) <== NOT EXECUTED 10fc93: 75 ef jne 10fc84 <== NOT EXECUTED return ap; return default_ap; } 10fc95: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10fc97: 5a pop %edx <== NOT EXECUTED 10fc98: 5b pop %ebx <== NOT EXECUTED 10fc99: 5e pop %esi <== NOT EXECUTED 10fc9a: 5f pop %edi <== NOT EXECUTED 10fc9b: c9 leave <== NOT EXECUTED 10fc9c: c3 ret <== NOT EXECUTED 10fc9d: 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++; 10fca0: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED for ( ; ap->name; ap++) 10fca3: 8b 73 0c mov 0xc(%ebx),%esi <== NOT EXECUTED 10fca6: 85 f6 test %esi,%esi <== NOT EXECUTED 10fca8: 74 eb je 10fc95 <== NOT EXECUTED 10fcaa: 89 da mov %ebx,%edx <== NOT EXECUTED 10fcac: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10fcae: eb dd jmp 10fc8d <== NOT EXECUTED 10fcb0: 89 d3 mov %edx,%ebx <== NOT EXECUTED if (ap->remote_value == remote_value) return ap; return default_ap; } 10fcb2: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10fcb4: 5a pop %edx <== NOT EXECUTED 10fcb5: 5b pop %ebx <== NOT EXECUTED 10fcb6: 5e pop %esi <== NOT EXECUTED 10fcb7: 5f pop %edi <== NOT EXECUTED 10fcb8: c9 leave <== NOT EXECUTED 10fcb9: c3 ret <== NOT EXECUTED 10fcba: 66 90 xchg %ax,%ax <== NOT EXECUTED uint32_t remote_value ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 10fcbc: 31 db xor %ebx,%ebx <== NOT EXECUTED for ( ; ap->name; ap++) if (ap->remote_value == remote_value) return ap; return default_ap; } 10fcbe: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10fcc0: 5a pop %edx <== NOT EXECUTED 10fcc1: 5b pop %ebx <== NOT EXECUTED 10fcc2: 5e pop %esi <== NOT EXECUTED 10fcc3: 5f pop %edi <== NOT EXECUTED 10fcc4: c9 leave <== NOT EXECUTED 10fcc5: c3 ret <== NOT EXECUTED 0010fcc8 : uint32_t rtems_assoc_remote_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 10fcc8: 55 push %ebp <== NOT EXECUTED 10fcc9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fccb: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 10fcce: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10fcd1: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10fcd4: e8 5f 04 00 00 call 110138 <== NOT EXECUTED if (nap) 10fcd9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fcdc: 85 c0 test %eax,%eax <== NOT EXECUTED 10fcde: 74 03 je 10fce3 <== NOT EXECUTED return nap->remote_value; 10fce0: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED return 0; } 10fce3: c9 leave <== NOT EXECUTED 10fce4: 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 f8 16 12 00 mov 0x1216f8,%eax <== NOT EXECUTED 10a78d: 40 inc %eax <== NOT EXECUTED 10a78e: a3 f8 16 12 00 mov %eax,0x1216f8 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10a793: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a796: 68 00 16 12 00 push $0x121600 <== NOT EXECUTED 10a79b: e8 50 1d 00 00 call 10c4f0 <_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 5d 14 00 00 call 10bc1c <_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 1c 16 12 00 mov 0x12161c,%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 4e 2a 00 00 call 10d228 <_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 17 2a 00 00 call 10d228 <_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 00 16 12 00 push $0x121600 <== NOT EXECUTED 10a83b: e8 a4 21 00 00 call 10c9e4 <_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 d6 30 00 00 call 10d930 <_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 00 16 12 00 push $0x121600 <== NOT EXECUTED 10a862: e8 09 1d 00 00 call 10c570 <_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 00 16 12 00 push $0x121600 <== NOT EXECUTED 10a86f: e8 3c 20 00 00 call 10c8b0 <_Objects_Free> <== NOT EXECUTED _Barrier_Free( the_barrier ); _Thread_Enable_dispatch(); 10a874: e8 af 29 00 00 call 10d228 <_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 00 16 12 00 push $0x121600 <== NOT EXECUTED 10a8a6: e8 91 22 00 00 call 10cb3c <_Objects_Name_to_id_u32> <== NOT EXECUTED 10a8ab: 8b 04 85 8c b2 11 00 mov 0x11b28c(,%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 00 16 12 00 push $0x121600 <== NOT EXECUTED 10a8d1: e8 0e 21 00 00 call 10c9e4 <_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 57 13 00 00 call 10bc50 <_CORE_barrier_Release> <== NOT EXECUTED 10a8f9: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10a8fb: e8 28 29 00 00 call 10d228 <_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 00 16 12 00 push $0x121600 <== NOT EXECUTED 10a92c: e8 b3 20 00 00 call 10c9e4 <_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 31 13 00 00 call 10bc80 <_CORE_barrier_Wait> <== NOT EXECUTED id, TRUE, timeout, NULL ); _Thread_Enable_dispatch(); 10a94f: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10a952: e8 d1 28 00 00 call 10d228 <_Thread_Enable_dispatch> <== NOT EXECUTED return _Barrier_Translate_core_barrier_return_code( 10a957: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a95a: a1 bc 17 12 00 mov 0x1217bc,%eax <== NOT EXECUTED 10a95f: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 10a962: e8 89 52 00 00 call 10fbf0 <_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 0010b678 : uint32_t api, uint32_t class, uint32_t node, uint32_t index ) { 10b678: 55 push %ebp <== NOT EXECUTED 10b679: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b67b: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b67e: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10b681: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10b684: c1 e0 1b shl $0x1b,%eax <== NOT EXECUTED 10b687: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10b68a: 09 d0 or %edx,%eax <== NOT EXECUTED 10b68c: 0b 45 14 or 0x14(%ebp),%eax <== NOT EXECUTED 10b68f: c1 e1 10 shl $0x10,%ecx <== NOT EXECUTED 10b692: 09 c8 or %ecx,%eax <== NOT EXECUTED return _Objects_Build_id( api, class, node, index ); } 10b694: c9 leave <== NOT EXECUTED 10b695: c3 ret <== NOT EXECUTED 0010b698 : char C1, char C2, char C3, char C4 ) { 10b698: 55 push %ebp <== NOT EXECUTED 10b699: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b69b: 0f be 45 0c movsbl 0xc(%ebp),%eax <== NOT EXECUTED 10b69f: c1 e0 10 shl $0x10,%eax <== NOT EXECUTED 10b6a2: 0f be 55 08 movsbl 0x8(%ebp),%edx <== NOT EXECUTED 10b6a6: c1 e2 18 shl $0x18,%edx <== NOT EXECUTED 10b6a9: 09 d0 or %edx,%eax <== NOT EXECUTED 10b6ab: 0f be 55 10 movsbl 0x10(%ebp),%edx <== NOT EXECUTED 10b6af: c1 e2 08 shl $0x8,%edx <== NOT EXECUTED 10b6b2: 09 d0 or %edx,%eax <== NOT EXECUTED 10b6b4: 0f be 55 14 movsbl 0x14(%ebp),%edx <== NOT EXECUTED 10b6b8: 09 d0 or %edx,%eax <== NOT EXECUTED return _Objects_Build_name( C1, C2, C3, C4 ); } 10b6ba: c9 leave <== NOT EXECUTED 10b6bb: 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 08 85 11 00 jmp *0x118508(,%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 0c ea 11 00 00 cmpb $0x0,0x11ea0c <== NOT EXECUTED 109b51: 74 0d je 109b60 <== NOT EXECUTED return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch; 109b53: a1 8c ea 11 00 mov 0x11ea8c,%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 c0 eb 11 00 divl 0x11ebc0 <== 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 64 eb 11 00 mov 0x11eb64,%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 0c ea 11 00 00 cmpb $0x0,0x11ea0c <== 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 31 16 00 00 call 10b1f8 <_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 14 6d 00 00 call 110900 <== 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 c0 eb 11 00 divl 0x11ebc0 <== 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 0c ea 11 00 00 cmpb $0x0,0x11ea0c <== 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 89 15 00 00 call 10b1f8 <_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 00109eb8 : * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { 109eb8: 55 push %ebp <== NOT EXECUTED 109eb9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109ebb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109ebe: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( !uptime ) 109ec1: 85 c0 test %eax,%eax <== NOT EXECUTED 109ec3: 74 13 je 109ed8 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime( uptime ); 109ec5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109ec8: 50 push %eax <== NOT EXECUTED 109ec9: e8 fe 16 00 00 call 10b5cc <_TOD_Get_uptime> <== NOT EXECUTED 109ece: 31 c0 xor %eax,%eax <== NOT EXECUTED 109ed0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 109ed3: c9 leave <== NOT EXECUTED 109ed4: c3 ret <== NOT EXECUTED 109ed5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { if ( !uptime ) 109ed8: b0 09 mov $0x9,%al <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime( uptime ); return RTEMS_SUCCESSFUL; } 109eda: c9 leave <== NOT EXECUTED 109edb: 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 20 a7 12 00 imul 0x12a720,%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 58 a5 12 00 mov 0x12a558,%eax <== NOT EXECUTED 10abae: 40 inc %eax <== NOT EXECUTED 10abaf: a3 58 a5 12 00 mov %eax,0x12a558 <== 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 c9 19 00 00 call 10c588 <_TOD_Set> <== NOT EXECUTED _Thread_Enable_dispatch(); 10abbf: e8 b0 2b 00 00 call 10d774 <_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 c8 eb 11 00 mov %eax,0x11ebc8 <== 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 cd 15 00 00 call 10b288 <_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 dc ea 11 00 push $0x11eadc <== NOT EXECUTED 109cc3: e8 8c 36 00 00 call 10d354 <_Watchdog_Tickle> <== NOT EXECUTED _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 109cc8: e8 37 31 00 00 call 10ce04 <_Thread_Tickle_timeslice> <== NOT EXECUTED 109ccd: a0 cc ea 11 00 mov 0x11eacc,%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 f8 e9 11 00 mov 0x11e9f8,%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 5f 24 00 00 call 10c14c <_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 50 4d 00 00 call 10c4f8 <_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 4c a8 12 00 push $0x12a84c <== NOT EXECUTED 1077b8: e8 9f 6e 00 00 call 10e65c <_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 74 b0 11 00 push $0x11b074 <== 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 2c a5 12 00 mov 0x12a52c(,%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 7b 6d 00 00 call 10e594 <_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 02 b1 11 00 push $0x11b102 <== 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 ef b0 11 00 push $0x11b0ef <== 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 1c a6 12 00 mov 0x12a61c,%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 24 a6 12 00 push $0x12a624 <== NOT EXECUTED 1078a6: e8 b1 6d 00 00 call 10e65c <_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 a5 6c 00 00 call 10e55c <_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 bc b0 11 00 push $0x11b0bc <== 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 4c a8 12 00 push $0x12a84c <== NOT EXECUTED 107933: e8 c0 4b 00 00 call 10c4f8 <_TOD_Get_uptime> <== NOT EXECUTED _Thread_Time_of_last_context_switch = CPU_usage_Uptime_at_last_reset; 107938: a1 4c a8 12 00 mov 0x12a84c,%eax <== NOT EXECUTED 10793d: 8b 15 50 a8 12 00 mov 0x12a850,%edx <== NOT EXECUTED 107943: a3 24 a6 12 00 mov %eax,0x12a624 <== NOT EXECUTED 107948: 89 15 28 a6 12 00 mov %edx,0x12a628 <== 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 82 4f 00 00 call 10c8dc <== NOT EXECUTED 10795a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10795d: c9 leave <== NOT EXECUTED 10795e: c3 ret <== NOT EXECUTED 0010ef78 : */ void rtems_debug_disable ( rtems_debug_control to_be_disabled ) { 10ef78: 55 push %ebp <== NOT EXECUTED 10ef79: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ef7b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED _Debug_Level &= ~to_be_disabled; 10ef7e: f7 d0 not %eax <== NOT EXECUTED 10ef80: 21 05 c0 ea 11 00 and %eax,0x11eac0 <== NOT EXECUTED } 10ef86: c9 leave <== NOT EXECUTED 10ef87: c3 ret <== NOT EXECUTED 0010ef68 : */ void rtems_debug_enable ( rtems_debug_control to_be_enabled ) { 10ef68: 55 push %ebp <== NOT EXECUTED 10ef69: 89 e5 mov %esp,%ebp <== NOT EXECUTED _Debug_Level |= to_be_enabled; 10ef6b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10ef6e: 09 05 c0 ea 11 00 or %eax,0x11eac0 <== NOT EXECUTED } 10ef74: c9 leave <== NOT EXECUTED 10ef75: c3 ret <== NOT EXECUTED 0010f8cc : { 0, 0, 0 }, }; static int rtems_deviceio_errno(rtems_status_code code) { 10f8cc: 55 push %ebp <== NOT EXECUTED 10f8cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f8cf: 53 push %ebx <== NOT EXECUTED 10f8d0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED int rc; if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t) code))) 10f8d3: 50 push %eax <== NOT EXECUTED 10f8d4: 68 c0 8a 11 00 push $0x118ac0 <== NOT EXECUTED 10f8d9: e8 ea 03 00 00 call 10fcc8 <== NOT EXECUTED 10f8de: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10f8e0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f8e3: 85 c0 test %eax,%eax <== NOT EXECUTED 10f8e5: 74 07 je 10f8ee <== NOT EXECUTED { errno = rc; 10f8e7: e8 cc 08 00 00 call 1101b8 <__errno> <== NOT EXECUTED 10f8ec: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return -1; } return -1; } 10f8ee: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10f8f3: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f8f6: c9 leave <== NOT EXECUTED 10f8f7: 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 bc ea 11 00 mov 0x11eabc,%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 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 109d21: 40 inc %eax <== NOT EXECUTED 109d22: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== 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 6f 25 00 00 call 10c2a8 <_Thread_Enable_dispatch> <== NOT EXECUTED return( _Thread_Executing->Wait.return_code ); 109d39: a1 bc ea 11 00 mov 0x11eabc,%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 31 24 00 00 call 10c2cc <_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 e3 23 00 00 call 10c2a8 <_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 0010f730 : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 10f730: 55 push %ebp <== NOT EXECUTED 10f731: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f733: 57 push %edi <== NOT EXECUTED 10f734: 56 push %esi <== NOT EXECUTED 10f735: 53 push %ebx <== NOT EXECUTED 10f736: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f739: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10f73c: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Extension_Control *the_extension; if ( !id ) 10f73f: 85 f6 test %esi,%esi <== NOT EXECUTED 10f741: 74 75 je 10f7b8 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10f743: 85 ff test %edi,%edi <== NOT EXECUTED 10f745: 75 0d jne 10f754 <== NOT EXECUTED 10f747: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED ); *id = the_extension->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10f74c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f74f: 5b pop %ebx <== NOT EXECUTED 10f750: 5e pop %esi <== NOT EXECUTED 10f751: 5f pop %edi <== NOT EXECUTED 10f752: c9 leave <== NOT EXECUTED 10f753: 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 10f754: a1 d8 c9 12 00 mov 0x12c9d8,%eax <== NOT EXECUTED 10f759: 40 inc %eax <== NOT EXECUTED 10f75a: a3 d8 c9 12 00 mov %eax,0x12c9d8 <== NOT EXECUTED * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 10f75f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f762: 68 60 cc 12 00 push $0x12cc60 <== NOT EXECUTED 10f767: e8 10 0c 00 00 call 11037c <_Objects_Allocate> <== NOT EXECUTED 10f76c: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 10f76e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f771: 85 c0 test %eax,%eax <== NOT EXECUTED 10f773: 74 37 je 10f7ac <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 10f775: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10f778: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10f77b: 8d 40 10 lea 0x10(%eax),%eax <== NOT EXECUTED 10f77e: 50 push %eax <== NOT EXECUTED 10f77f: e8 00 26 00 00 call 111d84 <_User_extensions_Add_set> <== NOT EXECUTED 10f784: 8b 4b 08 mov 0x8(%ebx),%ecx <== NOT EXECUTED 10f787: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 10f78a: a1 7c cc 12 00 mov 0x12cc7c,%eax <== NOT EXECUTED 10f78f: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 10f792: 89 7b 0c mov %edi,0xc(%ebx) <== NOT EXECUTED &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 10f795: 89 0e mov %ecx,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 10f797: e8 18 19 00 00 call 1110b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10f79c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f79e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10f7a1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f7a4: 5b pop %ebx <== NOT EXECUTED 10f7a5: 5e pop %esi <== NOT EXECUTED 10f7a6: 5f pop %edi <== NOT EXECUTED 10f7a7: c9 leave <== NOT EXECUTED 10f7a8: c3 ret <== NOT EXECUTED 10f7a9: 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(); 10f7ac: e8 03 19 00 00 call 1110b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10f7b1: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED 10f7b6: eb 94 jmp 10f74c <== NOT EXECUTED Objects_Id *id ) { Extension_Control *the_extension; if ( !id ) 10f7b8: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10f7bd: eb 8d jmp 10f74c <== NOT EXECUTED 0010f7c0 : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 10f7c0: 55 push %ebp <== NOT EXECUTED 10f7c1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f7c3: 53 push %ebx <== NOT EXECUTED 10f7c4: 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 10f7c7: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 10f7ca: 50 push %eax <== NOT EXECUTED 10f7cb: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10f7ce: 68 60 cc 12 00 push $0x12cc60 <== NOT EXECUTED 10f7d3: e8 98 10 00 00 call 110870 <_Objects_Get> <== NOT EXECUTED 10f7d8: 89 c3 mov %eax,%ebx <== NOT EXECUTED Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 10f7da: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f7dd: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 10f7e0: 85 c0 test %eax,%eax <== NOT EXECUTED 10f7e2: 75 38 jne 10f81c <== NOT EXECUTED case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 10f7e4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f7e7: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10f7ea: 50 push %eax <== NOT EXECUTED 10f7eb: e8 94 26 00 00 call 111e84 <_User_extensions_Remove_set> <== NOT EXECUTED _Objects_Close( &_Extension_Information, &the_extension->Object ); 10f7f0: 59 pop %ecx <== NOT EXECUTED 10f7f1: 58 pop %eax <== NOT EXECUTED 10f7f2: 53 push %ebx <== NOT EXECUTED 10f7f3: 68 60 cc 12 00 push $0x12cc60 <== NOT EXECUTED 10f7f8: e8 ff 0b 00 00 call 1103fc <_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 10f7fd: 58 pop %eax <== NOT EXECUTED 10f7fe: 5a pop %edx <== NOT EXECUTED 10f7ff: 53 push %ebx <== NOT EXECUTED 10f800: 68 60 cc 12 00 push $0x12cc60 <== NOT EXECUTED 10f805: e8 32 0f 00 00 call 11073c <_Objects_Free> <== NOT EXECUTED _Extension_Free( the_extension ); _Thread_Enable_dispatch(); 10f80a: e8 a5 18 00 00 call 1110b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 10f80f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f811: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f814: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f817: c9 leave <== NOT EXECUTED 10f818: c3 ret <== NOT EXECUTED 10f819: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 10f81c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10f821: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f824: c9 leave <== NOT EXECUTED 10f825: c3 ret <== NOT EXECUTED 0010c44c : rtems_status_code rtems_extension_ident( rtems_name name, Objects_Id *id ) { 10c44c: 55 push %ebp <== NOT EXECUTED 10c44d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c44f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED Objects_Name_or_id_lookup_errors status; status = _Objects_Name_to_id_u32( 10c452: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10c455: 68 ff ff ff 7f push $0x7fffffff <== NOT EXECUTED 10c45a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10c45d: 68 a0 2b 12 00 push $0x122ba0 <== NOT EXECUTED 10c462: e8 a9 11 00 00 call 10d610 <_Objects_Name_to_id_u32> <== NOT EXECUTED 10c467: 8b 04 85 ac c6 11 00 mov 0x11c6ac(,%eax,4),%eax <== NOT EXECUTED OBJECTS_SEARCH_LOCAL_NODE, id ); return _Status_Object_name_errors_to_status[ status ]; } 10c46e: c9 leave <== NOT EXECUTED 10c46f: c3 ret <== NOT EXECUTED 0010aa40 : */ void rtems_fatal_error_occurred( uint32_t the_error ) { 10aa40: 55 push %ebp <== NOT EXECUTED 10aa41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10aa43: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, FALSE, the_error ); 10aa46: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10aa49: 6a 00 push $0x0 <== NOT EXECUTED 10aa4b: 6a 01 push $0x1 <== NOT EXECUTED 10aa4d: e8 8a 0a 00 00 call 10b4dc <_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 d3 83 11 00 push $0x1183d3 <== 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 83 92 00 00 call 1101b8 <__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 6a 92 00 00 call 1101b8 <__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 54 c8 11 00 mov 0x11c854,%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 54 c8 11 00 mov 0x11c854,%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 5f 91 00 00 call 1101b8 <__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 3b 91 00 00 call 1101b8 <__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 29 91 00 00 call 1101b8 <__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 0010e360 : * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) { 10e360: 55 push %ebp <== NOT EXECUTED 10e361: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e363: 57 push %edi <== NOT EXECUTED 10e364: 56 push %esi <== NOT EXECUTED 10e365: 53 push %ebx <== NOT EXECUTED 10e366: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED /* * Set the default umask to "022". */ rtems_filesystem_umask = 022; 10e369: a1 54 c8 11 00 mov 0x11c854,%eax <== NOT EXECUTED 10e36e: c7 40 24 12 00 00 00 movl $0x12,0x24(%eax) <== NOT EXECUTED init_fs_mount_table(); 10e375: e8 5a 05 00 00 call 10e8d4 <== NOT EXECUTED /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) 10e37a: a1 ec 6e 11 00 mov 0x116eec,%eax <== NOT EXECUTED 10e37f: 85 c0 test %eax,%eax <== NOT EXECUTED 10e381: 0f 84 a5 00 00 00 je 10e42c <== NOT EXECUTED rtems_fatal_error_occurred( 0xABCD0001 ); mt = &rtems_filesystem_mount_table[0]; 10e387: a1 e8 a3 11 00 mov 0x11a3e8,%eax <== NOT EXECUTED status = mount( 10e38c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e38f: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10e392: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10e395: ff 70 04 pushl 0x4(%eax) <== NOT EXECUTED 10e398: ff 30 pushl (%eax) <== NOT EXECUTED 10e39a: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10e39d: 50 push %eax <== NOT EXECUTED 10e39e: e8 59 05 00 00 call 10e8fc <== NOT EXECUTED &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point ); if ( status == -1 ) 10e3a3: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10e3a6: 40 inc %eax <== NOT EXECUTED 10e3a7: 0f 84 8c 00 00 00 je 10e439 <== NOT EXECUTED rtems_fatal_error_occurred( 0xABCD0002 ); rtems_filesystem_link_counts = 0; 10e3ad: a1 54 c8 11 00 mov 0x11c854,%eax <== NOT EXECUTED 10e3b2: 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; 10e3b8: 8d 78 14 lea 0x14(%eax),%edi <== NOT EXECUTED 10e3bb: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10e3be: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 10e3c1: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10e3c6: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 10e3c8: 6a 00 push $0x0 <== NOT EXECUTED 10e3ca: 8d 5d e0 lea -0x20(%ebp),%ebx <== NOT EXECUTED 10e3cd: 53 push %ebx <== NOT EXECUTED 10e3ce: 6a 00 push $0x0 <== NOT EXECUTED 10e3d0: 68 98 89 11 00 push $0x118998 <== NOT EXECUTED 10e3d5: e8 82 8b ff ff call 106f5c <== NOT EXECUTED rtems_filesystem_root = loc; 10e3da: a1 54 c8 11 00 mov 0x11c854,%eax <== NOT EXECUTED 10e3df: 8d 78 14 lea 0x14(%eax),%edi <== NOT EXECUTED 10e3e2: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10e3e7: 89 de mov %ebx,%esi <== NOT EXECUTED 10e3e9: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 10e3eb: 6a 00 push $0x0 <== NOT EXECUTED 10e3ed: 53 push %ebx <== NOT EXECUTED 10e3ee: 6a 00 push $0x0 <== NOT EXECUTED 10e3f0: 68 98 89 11 00 push $0x118998 <== NOT EXECUTED 10e3f5: e8 62 8b ff ff call 106f5c <== NOT EXECUTED rtems_filesystem_current = loc; 10e3fa: a1 54 c8 11 00 mov 0x11c854,%eax <== NOT EXECUTED 10e3ff: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 10e402: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10e407: 89 de mov %ebx,%esi <== NOT EXECUTED 10e409: 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); 10e40b: 83 c4 18 add $0x18,%esp <== NOT EXECUTED 10e40e: 68 ff 01 00 00 push $0x1ff <== NOT EXECUTED 10e413: 68 9a 89 11 00 push $0x11899a <== NOT EXECUTED 10e418: e8 9b 04 00 00 call 10e8b8 <== NOT EXECUTED if ( status != 0 ) 10e41d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e420: 85 c0 test %eax,%eax <== NOT EXECUTED 10e422: 75 22 jne 10e446 <== NOT EXECUTED * before device drivers are initialized. So we return via a base * filesystem image and nothing auto-mounted at this point. */ #endif } 10e424: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e427: 5b pop %ebx <== NOT EXECUTED 10e428: 5e pop %esi <== NOT EXECUTED 10e429: 5f pop %edi <== NOT EXECUTED 10e42a: c9 leave <== NOT EXECUTED 10e42b: c3 ret <== NOT EXECUTED /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) rtems_fatal_error_occurred( 0xABCD0001 ); 10e42c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e42f: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED 10e434: e8 07 c6 ff ff call 10aa40 <== NOT EXECUTED status = mount( &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point ); if ( status == -1 ) rtems_fatal_error_occurred( 0xABCD0002 ); 10e439: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e43c: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED 10e441: e8 fa c5 ff ff call 10aa40 <== NOT EXECUTED * created that way by the IMFS. */ status = mkdir( "/dev", 0777); if ( status != 0 ) rtems_fatal_error_occurred( 0xABCD0003 ); 10e446: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e449: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED 10e44e: e8 ed c5 ff ff call 10aa40 <== NOT EXECUTED 0012553c : ); bool rtems_filesystem_nodes_equal( const rtems_filesystem_location_info_t *loc1, const rtems_filesystem_location_info_t *loc2 ){ 12553c: 55 push %ebp <== NOT EXECUTED 12553d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12553f: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 125542: 8b 10 mov (%eax),%edx <== NOT EXECUTED 125544: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 125547: 3b 10 cmp (%eax),%edx <== NOT EXECUTED 125549: 0f 94 c0 sete %al <== NOT EXECUTED return ( loc1->node_access == loc2->node_access ); } 12554c: c9 leave <== NOT EXECUTED 12554d: c3 ret <== NOT EXECUTED 0010c204 : #endif #include const char *rtems_get_version_string(void) { 10c204: 55 push %ebp <== NOT EXECUTED 10c205: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _RTEMS_version; } 10c207: b8 60 de 11 00 mov $0x11de60,%eax <== NOT EXECUTED 10c20c: c9 leave <== NOT EXECUTED 10c20d: 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 ab 02 00 00 jmp 10abb4 <_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 ec 00 00 00 je 10aa0d <== NOT EXECUTED ); /* * Provide pointers just for later convenience. */ _Configuration_Table = configuration_table; 10a921: 89 1d 94 ea 11 00 mov %ebx,0x11ea94 <== 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 4c c1 10 00 push $0x10c14c <== NOT EXECUTED 10a92f: e8 0c 2d 00 00 call 10d640 <_CPU_Initialize> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 10a934: c7 05 c4 eb 11 00 00 movl $0x0,0x11ebc4 <== 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 15 46 00 00 call 10ef58 <_Debug_Manager_initialization> <== NOT EXECUTED _API_extensions_Initialization(); 10a943: e8 48 02 00 00 call 10ab90 <_API_extensions_Initialization> <== NOT EXECUTED 10a948: c7 05 f8 e9 11 00 01 movl $0x1,0x11e9f8 <== 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 be 2a 00 00 call 10d41c <_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 e1 25 00 00 call 10cf4c <_User_extensions_Handler_initialization> <== NOT EXECUTED configuration_table->number_of_initial_extensions, configuration_table->User_extension_table ); _ISR_Handler_initialization(); 10a96b: e8 ac 0b 00 00 call 10b51c <_ISR_Handler_initialization> <== NOT EXECUTED _Objects_Handler_initialization( 10a970: e8 cb 12 00 00 call 10bc40 <_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 d0 e9 11 00 10 movl $0x11ea10,0x11e9d0 <== NOT EXECUTED 10a97c: ea 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 5d 03 00 00 call 10ace8 <_API_Mutex_Initialization> <== NOT EXECUTED _API_Mutex_Allocate( &_RTEMS_Allocator_Mutex ); 10a98b: c7 04 24 b4 ea 11 00 movl $0x11eab4,(%esp) <== NOT EXECUTED 10a992: e8 d1 02 00 00 call 10ac68 <_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 b0 ea 11 00 movw $0x0,0x11eab0 <== 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 40 eb 11 movw $0x0,0x11eb40(%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 cb 28 00 00 call 10d288 <_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 84 08 00 00 call 10b24c <_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 7f 1b 00 00 call 10c554 <_Thread_Handler_initialization> <== NOT EXECUTED ); #endif /* MANAGERS */ _RTEMS_API_Initialize( configuration_table ); 10a9d5: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10a9d8: e8 2f 01 00 00 call 10ab0c <_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 36 00 00 00 call 10aa1c <_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 8d 00 00 00 call 10aa84 <_IO_Manager_initialization> <== 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( 10a9f7: c7 05 c4 eb 11 00 01 movl $0x1,0x11ebc4 <== NOT EXECUTED 10a9fe: 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(); 10aa01: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Scheduling can properly occur now as long as we avoid dispatching. */ } 10aa04: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10aa07: 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(); 10aa08: e9 67 16 00 00 jmp 10c074 <_Thread_Create_idle> <== NOT EXECUTED /* * Make sure the parameters were not NULL. */ if ( configuration_table == NULL ) _Internal_error_Occurred( 10aa0d: 50 push %eax <== NOT EXECUTED 10aa0e: 6a 00 push $0x0 <== NOT EXECUTED 10aa10: 6a 01 push $0x1 <== NOT EXECUTED 10aa12: 6a 00 push $0x0 <== NOT EXECUTED 10aa14: e8 c3 0a 00 00 call 10b4dc <_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 5d 01 00 00 call 10aa54 <_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 e7 02 00 00 jmp 10abe4 <_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 c4 eb 11 00 02 movl $0x2,0x11ebc4 <== 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 5d 24 00 00 jmp 10cd48 <_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 38 17 12 00 mov 0x121738,%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 0010fe40 : rtems_status_code rtems_io_close( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10fe40: 55 push %ebp <== NOT EXECUTED 10fe41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fe43: 56 push %esi <== NOT EXECUTED 10fe44: 53 push %ebx <== NOT EXECUTED 10fe45: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10fe48: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10fe4b: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10fe4e: 39 0d a0 ed 11 00 cmp %ecx,0x11eda0 <== NOT EXECUTED 10fe54: 76 1e jbe 10fe74 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].close_entry; 10fe56: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 10fe59: a1 a4 ed 11 00 mov 0x11eda4,%eax <== NOT EXECUTED 10fe5e: 8b 44 d0 08 mov 0x8(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10fe62: 85 c0 test %eax,%eax <== NOT EXECUTED 10fe64: 74 13 je 10fe79 <== NOT EXECUTED 10fe66: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10fe69: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10fe6c: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10fe6f: 5b pop %ebx <== NOT EXECUTED 10fe70: 5e pop %esi <== NOT EXECUTED 10fe71: 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; 10fe72: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10fe74: 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; } 10fe79: 5b pop %ebx <== NOT EXECUTED 10fe7a: 5e pop %esi <== NOT EXECUTED 10fe7b: c9 leave <== NOT EXECUTED 10fe7c: c3 ret <== NOT EXECUTED 0010fe80 : rtems_status_code rtems_io_control( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10fe80: 55 push %ebp <== NOT EXECUTED 10fe81: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fe83: 56 push %esi <== NOT EXECUTED 10fe84: 53 push %ebx <== NOT EXECUTED 10fe85: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10fe88: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10fe8b: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10fe8e: 39 0d a0 ed 11 00 cmp %ecx,0x11eda0 <== NOT EXECUTED 10fe94: 76 1e jbe 10feb4 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].control_entry; 10fe96: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 10fe99: a1 a4 ed 11 00 mov 0x11eda4,%eax <== NOT EXECUTED 10fe9e: 8b 44 d0 14 mov 0x14(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10fea2: 85 c0 test %eax,%eax <== NOT EXECUTED 10fea4: 74 13 je 10feb9 <== NOT EXECUTED 10fea6: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10fea9: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10feac: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10feaf: 5b pop %ebx <== NOT EXECUTED 10feb0: 5e pop %esi <== NOT EXECUTED 10feb1: 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; 10feb2: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10feb4: 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; } 10feb9: 5b pop %ebx <== NOT EXECUTED 10feba: 5e pop %esi <== NOT EXECUTED 10febb: c9 leave <== NOT EXECUTED 10febc: c3 ret <== NOT EXECUTED 0010ef9c : rtems_status_code rtems_io_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10ef9c: 55 push %ebp <== NOT EXECUTED 10ef9d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ef9f: 56 push %esi <== NOT EXECUTED 10efa0: 53 push %ebx <== NOT EXECUTED 10efa1: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10efa4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10efa7: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10efaa: 39 0d a0 ed 11 00 cmp %ecx,0x11eda0 <== NOT EXECUTED 10efb0: 76 1e jbe 10efd0 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].initialization_entry; 10efb2: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 10efb5: a1 a4 ed 11 00 mov 0x11eda4,%eax <== NOT EXECUTED 10efba: 8b 04 d0 mov (%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10efbd: 85 c0 test %eax,%eax <== NOT EXECUTED 10efbf: 74 14 je 10efd5 <== NOT EXECUTED 10efc1: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10efc4: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10efc7: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10efca: 5b pop %ebx <== NOT EXECUTED 10efcb: 5e pop %esi <== NOT EXECUTED 10efcc: 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; 10efcd: ff e0 jmp *%eax <== NOT EXECUTED 10efcf: 90 nop <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10efd0: 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; } 10efd5: 5b pop %ebx <== NOT EXECUTED 10efd6: 5e pop %esi <== NOT EXECUTED 10efd7: c9 leave <== NOT EXECUTED 10efd8: 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 f3 93 00 00 call 1101b8 <__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 0010fec0 : rtems_status_code rtems_io_open( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10fec0: 55 push %ebp <== NOT EXECUTED 10fec1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fec3: 56 push %esi <== NOT EXECUTED 10fec4: 53 push %ebx <== NOT EXECUTED 10fec5: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10fec8: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10fecb: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10fece: 39 0d a0 ed 11 00 cmp %ecx,0x11eda0 <== NOT EXECUTED 10fed4: 76 1e jbe 10fef4 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].open_entry; 10fed6: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 10fed9: a1 a4 ed 11 00 mov 0x11eda4,%eax <== NOT EXECUTED 10fede: 8b 44 d0 04 mov 0x4(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10fee2: 85 c0 test %eax,%eax <== NOT EXECUTED 10fee4: 74 13 je 10fef9 <== NOT EXECUTED 10fee6: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10fee9: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10feec: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10feef: 5b pop %ebx <== NOT EXECUTED 10fef0: 5e pop %esi <== NOT EXECUTED 10fef1: 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; 10fef2: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10fef4: 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; } 10fef9: 5b pop %ebx <== NOT EXECUTED 10fefa: 5e pop %esi <== NOT EXECUTED 10fefb: c9 leave <== NOT EXECUTED 10fefc: c3 ret <== NOT EXECUTED 0010ff00 : rtems_status_code rtems_io_read( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10ff00: 55 push %ebp <== NOT EXECUTED 10ff01: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ff03: 56 push %esi <== NOT EXECUTED 10ff04: 53 push %ebx <== NOT EXECUTED 10ff05: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ff08: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10ff0b: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10ff0e: 39 0d a0 ed 11 00 cmp %ecx,0x11eda0 <== NOT EXECUTED 10ff14: 76 1e jbe 10ff34 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].read_entry; 10ff16: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 10ff19: a1 a4 ed 11 00 mov 0x11eda4,%eax <== NOT EXECUTED 10ff1e: 8b 44 d0 0c mov 0xc(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10ff22: 85 c0 test %eax,%eax <== NOT EXECUTED 10ff24: 74 13 je 10ff39 <== NOT EXECUTED 10ff26: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10ff29: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10ff2c: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10ff2f: 5b pop %ebx <== NOT EXECUTED 10ff30: 5e pop %esi <== NOT EXECUTED 10ff31: 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; 10ff32: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10ff34: 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; } 10ff39: 5b pop %ebx <== NOT EXECUTED 10ff3a: 5e pop %esi <== NOT EXECUTED 10ff3b: c9 leave <== NOT EXECUTED 10ff3c: c3 ret <== NOT EXECUTED 0010b88c : 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 ) { 10b88c: 55 push %ebp <== NOT EXECUTED 10b88d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b88f: 57 push %edi <== NOT EXECUTED 10b890: 56 push %esi <== NOT EXECUTED 10b891: 53 push %ebx <== NOT EXECUTED 10b892: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b895: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10b898: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10b89b: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 10b89e: 85 f6 test %esi,%esi <== NOT EXECUTED 10b8a0: 0f 84 c6 00 00 00 je 10b96c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 10b8a6: 85 db test %ebx,%ebx <== NOT EXECUTED 10b8a8: 0f 84 be 00 00 00 je 10b96c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 10b8ae: 8b 06 mov (%esi),%eax <== NOT EXECUTED 10b8b0: 85 c0 test %eax,%eax <== NOT EXECUTED 10b8b2: 0f 84 a8 00 00 00 je 10b960 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; *registered_major = 0; 10b8b8: 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 ) 10b8be: a1 84 19 12 00 mov 0x121984,%eax <== NOT EXECUTED 10b8c3: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10b8c5: 76 5d jbe 10b924 <== NOT EXECUTED /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 10b8c7: 85 d2 test %edx,%edx <== NOT EXECUTED 10b8c9: 75 65 jne 10b930 <== NOT EXECUTED bool found = false; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 10b8cb: 89 c2 mov %eax,%edx <== NOT EXECUTED 10b8cd: 4a dec %edx <== NOT EXECUTED 10b8ce: 0f 84 80 00 00 00 je 10b954 <== NOT EXECUTED 10b8d4: 8d 04 40 lea (%eax,%eax,2),%eax <== NOT EXECUTED 10b8d7: 8d 04 c5 e8 ff ff ff lea -0x18(,%eax,8),%eax <== NOT EXECUTED 10b8de: 03 05 88 19 12 00 add 0x121988,%eax <== NOT EXECUTED 10b8e4: eb 08 jmp 10b8ee <== NOT EXECUTED 10b8e6: 66 90 xchg %ax,%ax <== NOT EXECUTED 10b8e8: 83 e8 18 sub $0x18,%eax <== NOT EXECUTED 10b8eb: 4a dec %edx <== NOT EXECUTED 10b8ec: 74 66 je 10b954 <== NOT EXECUTED 10b8ee: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( !_IO_Driver_address_table[major].initialization_entry && 10b8f0: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 10b8f2: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b8f4: 75 f2 jne 10b8e8 <== NOT EXECUTED 10b8f6: 8b 48 04 mov 0x4(%eax),%ecx <== NOT EXECUTED 10b8f9: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b8fb: 75 eb jne 10b8e8 <== 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; 10b8fd: b8 06 00 00 00 mov $0x6,%eax <== NOT EXECUTED 10b902: 89 c1 mov %eax,%ecx <== NOT EXECUTED 10b904: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *registered_major = major; 10b906: 89 13 mov %edx,(%ebx) <== NOT EXECUTED return rtems_io_initialize( major, 0, NULL ); 10b908: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) <== NOT EXECUTED 10b90f: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) <== NOT EXECUTED 10b916: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 10b919: 59 pop %ecx <== NOT EXECUTED 10b91a: 5b pop %ebx <== NOT EXECUTED 10b91b: 5e pop %esi <== NOT EXECUTED 10b91c: 5f pop %edi <== NOT EXECUTED 10b91d: c9 leave <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b91e: e9 f1 fd ff ff jmp 10b714 <== NOT EXECUTED 10b923: 90 nop <== NOT EXECUTED *registered_major = 0; /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 10b924: 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 ); } 10b929: 5a pop %edx <== NOT EXECUTED 10b92a: 5b pop %ebx <== NOT EXECUTED 10b92b: 5e pop %esi <== NOT EXECUTED 10b92c: 5f pop %edi <== NOT EXECUTED 10b92d: c9 leave <== NOT EXECUTED 10b92e: c3 ret <== NOT EXECUTED 10b92f: 90 nop <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 10b930: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10b933: 8d 3c c5 00 00 00 00 lea 0x0(,%eax,8),%edi <== NOT EXECUTED 10b93a: 03 3d 88 19 12 00 add 0x121988,%edi <== NOT EXECUTED 10b940: 8b 07 mov (%edi),%eax <== NOT EXECUTED 10b942: 85 c0 test %eax,%eax <== NOT EXECUTED 10b944: 74 32 je 10b978 <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b946: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED } 10b94b: 5a pop %edx <== NOT EXECUTED 10b94c: 5b pop %ebx <== NOT EXECUTED 10b94d: 5e pop %esi <== NOT EXECUTED 10b94e: 5f pop %edi <== NOT EXECUTED 10b94f: c9 leave <== NOT EXECUTED 10b950: c3 ret <== NOT EXECUTED 10b951: 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 ); 10b954: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED } 10b959: 5a pop %edx <== NOT EXECUTED 10b95a: 5b pop %ebx <== NOT EXECUTED 10b95b: 5e pop %esi <== NOT EXECUTED 10b95c: 5f pop %edi <== NOT EXECUTED 10b95d: c9 leave <== NOT EXECUTED 10b95e: c3 ret <== NOT EXECUTED 10b95f: 90 nop <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !registered_major ) return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 10b960: 8b 7e 04 mov 0x4(%esi),%edi <== NOT EXECUTED 10b963: 85 ff test %edi,%edi <== NOT EXECUTED 10b965: 0f 85 4d ff ff ff jne 10b8b8 <== NOT EXECUTED 10b96b: 90 nop <== NOT EXECUTED _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b96c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } 10b971: 5a pop %edx <== NOT EXECUTED 10b972: 5b pop %ebx <== NOT EXECUTED 10b973: 5e pop %esi <== NOT EXECUTED 10b974: 5f pop %edi <== NOT EXECUTED 10b975: c9 leave <== NOT EXECUTED 10b976: c3 ret <== NOT EXECUTED 10b977: 90 nop <== NOT EXECUTED if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 10b978: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 10b97b: 85 c0 test %eax,%eax <== NOT EXECUTED 10b97d: 75 c7 jne 10b946 <== NOT EXECUTED 10b97f: e9 79 ff ff ff jmp 10b8fd <== 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 0010b984 : */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 10b984: 55 push %ebp <== NOT EXECUTED 10b985: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b987: 57 push %edi <== NOT EXECUTED 10b988: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10b98b: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED if ( major < _IO_Number_of_drivers ) { 10b98e: 39 05 84 19 12 00 cmp %eax,0x121984 <== NOT EXECUTED 10b994: 77 0a ja 10b9a0 <== NOT EXECUTED 10b996: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED sizeof( rtems_driver_address_table ) ); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10b99b: 5a pop %edx <== NOT EXECUTED 10b99c: 5f pop %edi <== NOT EXECUTED 10b99d: c9 leave <== NOT EXECUTED 10b99e: c3 ret <== NOT EXECUTED 10b99f: 90 nop <== NOT EXECUTED rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { if ( major < _IO_Number_of_drivers ) { memset( 10b9a0: 8d 3c 40 lea (%eax,%eax,2),%edi <== NOT EXECUTED 10b9a3: c1 e7 03 shl $0x3,%edi <== NOT EXECUTED 10b9a6: 03 3d 88 19 12 00 add 0x121988,%edi <== NOT EXECUTED 10b9ac: b9 18 00 00 00 mov $0x18,%ecx <== NOT EXECUTED 10b9b1: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b9b3: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 10b9b5: 31 c0 xor %eax,%eax <== NOT EXECUTED sizeof( rtems_driver_address_table ) ); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10b9b7: 5a pop %edx <== NOT EXECUTED 10b9b8: 5f pop %edi <== NOT EXECUTED 10b9b9: c9 leave <== NOT EXECUTED 10b9ba: c3 ret <== NOT EXECUTED 0010ff40 : rtems_status_code rtems_io_write( rtems_device_major_number major, rtems_device_minor_number minor, void *argument ) { 10ff40: 55 push %ebp <== NOT EXECUTED 10ff41: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10ff43: 56 push %esi <== NOT EXECUTED 10ff44: 53 push %ebx <== NOT EXECUTED 10ff45: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10ff48: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 10ff4b: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10ff4e: 39 0d a0 ed 11 00 cmp %ecx,0x11eda0 <== NOT EXECUTED 10ff54: 76 1e jbe 10ff74 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; callout = _IO_Driver_address_table[major].write_entry; 10ff56: 8d 14 49 lea (%ecx,%ecx,2),%edx <== NOT EXECUTED 10ff59: a1 a4 ed 11 00 mov 0x11eda4,%eax <== NOT EXECUTED 10ff5e: 8b 44 d0 10 mov 0x10(%eax,%edx,8),%eax <== NOT EXECUTED return callout ? callout(major, minor, argument) : RTEMS_SUCCESSFUL; 10ff62: 85 c0 test %eax,%eax <== NOT EXECUTED 10ff64: 74 13 je 10ff79 <== NOT EXECUTED 10ff66: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 10ff69: 89 75 0c mov %esi,0xc(%ebp) <== NOT EXECUTED 10ff6c: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 10ff6f: 5b pop %ebx <== NOT EXECUTED 10ff70: 5e pop %esi <== NOT EXECUTED 10ff71: 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; 10ff72: ff e0 jmp *%eax <== NOT EXECUTED void *argument ) { rtems_device_driver_entry callout; if ( major >= _IO_Number_of_drivers ) 10ff74: 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; } 10ff79: 5b pop %ebx <== NOT EXECUTED 10ff7a: 5e pop %esi <== NOT EXECUTED 10ff7b: c9 leave <== NOT EXECUTED 10ff7c: c3 ret <== NOT EXECUTED 0010c8dc : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10c8dc: 55 push %ebp <== NOT EXECUTED 10c8dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10c8df: 57 push %edi <== NOT EXECUTED 10c8e0: 56 push %esi <== NOT EXECUTED 10c8e1: 53 push %ebx <== NOT EXECUTED 10c8e2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10c8e5: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10c8e8: 85 c0 test %eax,%eax <== NOT EXECUTED 10c8ea: 74 47 je 10c933 <== NOT EXECUTED return; 10c8ec: 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 ] ) 10c8f1: 8b 04 bd 2c a5 12 00 mov 0x12a52c(,%edi,4),%eax <== NOT EXECUTED 10c8f8: 85 c0 test %eax,%eax <== NOT EXECUTED 10c8fa: 74 31 je 10c92d <== NOT EXECUTED continue; information = _Objects_Information_table[ api_index ][ 1 ]; 10c8fc: 8b 70 04 mov 0x4(%eax),%esi <== NOT EXECUTED if ( information ) { 10c8ff: 85 f6 test %esi,%esi <== NOT EXECUTED 10c901: 74 2a je 10c92d <== NOT EXECUTED for ( i=1 ; i <= information->maximum ; i++ ) { 10c903: 66 83 7e 10 00 cmpw $0x0,0x10(%esi) <== NOT EXECUTED 10c908: 74 23 je 10c92d <== NOT EXECUTED 10c90a: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10c90f: 90 nop <== NOT EXECUTED the_thread = (Thread_Control *)information->local_table[ i ]; 10c910: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 10c913: 8b 04 98 mov (%eax,%ebx,4),%eax <== NOT EXECUTED if ( !the_thread ) 10c916: 85 c0 test %eax,%eax <== NOT EXECUTED 10c918: 74 0a je 10c924 <== NOT EXECUTED continue; (*routine)(the_thread); 10c91a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c91d: 50 push %eax <== NOT EXECUTED 10c91e: ff 55 08 call *0x8(%ebp) <== NOT EXECUTED 10c921: 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++ ) { 10c924: 43 inc %ebx <== NOT EXECUTED 10c925: 0f b7 46 10 movzwl 0x10(%esi),%eax <== NOT EXECUTED 10c929: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 10c92b: 73 e3 jae 10c910 <== NOT EXECUTED if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10c92d: 47 inc %edi <== NOT EXECUTED if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 10c92e: 83 ff 05 cmp $0x5,%edi <== NOT EXECUTED 10c931: 75 be jne 10c8f1 <== NOT EXECUTED (*routine)(the_thread); } } } } 10c933: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10c936: 5b pop %ebx <== NOT EXECUTED 10c937: 5e pop %esi <== NOT EXECUTED 10c938: 5f pop %edi <== NOT EXECUTED 10c939: c9 leave <== NOT EXECUTED 10c93a: c3 ret <== NOT EXECUTED 0010e7c4 : * 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 ) { 10e7c4: 55 push %ebp <== NOT EXECUTED 10e7c5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e7c7: 57 push %edi <== NOT EXECUTED 10e7c8: 56 push %esi <== NOT EXECUTED 10e7c9: 53 push %ebx <== NOT EXECUTED 10e7ca: 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 ); 10e7cd: 6a 00 push $0x0 <== NOT EXECUTED 10e7cf: 6a 00 push $0x0 <== NOT EXECUTED 10e7d1: ff 35 78 e8 11 00 pushl 0x11e878 <== NOT EXECUTED 10e7d7: e8 d0 bb ff ff call 10a3ac <== NOT EXECUTED if (rtems_libio_iop_freelist) { 10e7dc: 8b 15 74 e8 11 00 mov 0x11e874,%edx <== NOT EXECUTED 10e7e2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e7e5: 85 d2 test %edx,%edx <== NOT EXECUTED 10e7e7: 75 1b jne 10e804 <== NOT EXECUTED } failed: iop = 0; done: 10e7e9: 31 db xor %ebx,%ebx <== NOT EXECUTED rtems_semaphore_release( rtems_libio_semaphore ); 10e7eb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e7ee: ff 35 78 e8 11 00 pushl 0x11e878 <== NOT EXECUTED 10e7f4: e8 ab bc ff ff call 10a4a4 <== NOT EXECUTED return iop; } 10e7f9: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e7fb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e7fe: 5b pop %ebx <== NOT EXECUTED 10e7ff: 5e pop %esi <== NOT EXECUTED 10e800: 5f pop %edi <== NOT EXECUTED 10e801: c9 leave <== NOT EXECUTED 10e802: c3 ret <== NOT EXECUTED 10e803: 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( 10e804: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e807: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10e80a: 50 push %eax <== NOT EXECUTED 10e80b: 6a 00 push $0x0 <== NOT EXECUTED 10e80d: 6a 54 push $0x54 <== NOT EXECUTED 10e80f: 6a 01 push $0x1 <== NOT EXECUTED 10e811: 89 d1 mov %edx,%ecx <== NOT EXECUTED 10e813: 2b 0d 70 e8 11 00 sub 0x11e870,%ecx <== NOT EXECUTED 10e819: c1 f9 02 sar $0x2,%ecx <== NOT EXECUTED 10e81c: 8d 14 89 lea (%ecx,%ecx,4),%edx <== NOT EXECUTED 10e81f: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 10e822: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e824: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 10e827: 29 d0 sub %edx,%eax <== NOT EXECUTED 10e829: 89 c2 mov %eax,%edx <== NOT EXECUTED 10e82b: c1 e2 0c shl $0xc,%edx <== NOT EXECUTED 10e82e: 01 d0 add %edx,%eax <== NOT EXECUTED 10e830: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED 10e833: 8d 04 41 lea (%ecx,%eax,2),%eax <== NOT EXECUTED 10e836: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 10e839: 01 c8 add %ecx,%eax <== NOT EXECUTED 10e83b: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED 10e83e: 0d 00 49 42 4c or $0x4c424900,%eax <== NOT EXECUTED 10e843: 50 push %eax <== NOT EXECUTED 10e844: e8 e3 b8 ff ff call 10a12c <== NOT EXECUTED 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &sema ); if (rc != RTEMS_SUCCESSFUL) 10e849: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 10e84c: 85 c0 test %eax,%eax <== NOT EXECUTED 10e84e: 75 99 jne 10e7e9 <== NOT EXECUTED goto failed; iop = rtems_libio_iop_freelist; 10e850: 8b 1d 74 e8 11 00 mov 0x11e874,%ebx <== NOT EXECUTED next = iop->data1; 10e856: 8b 73 28 mov 0x28(%ebx),%esi <== NOT EXECUTED (void) memset( iop, 0, sizeof(rtems_libio_t) ); 10e859: b9 34 00 00 00 mov $0x34,%ecx <== NOT EXECUTED 10e85e: 31 d2 xor %edx,%edx <== NOT EXECUTED 10e860: 89 df mov %ebx,%edi <== NOT EXECUTED 10e862: 88 d0 mov %dl,%al <== NOT EXECUTED 10e864: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED iop->flags = LIBIO_FLAGS_OPEN; 10e866: c7 43 0c 00 01 00 00 movl $0x100,0xc(%ebx) <== NOT EXECUTED iop->sem = sema; 10e86d: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10e870: 89 53 20 mov %edx,0x20(%ebx) <== NOT EXECUTED rtems_libio_iop_freelist = next; 10e873: 89 35 74 e8 11 00 mov %esi,0x11e874 <== NOT EXECUTED 10e879: e9 6d ff ff ff jmp 10e7eb <== NOT EXECUTED 0010e880 : }; uint32_t rtems_libio_fcntl_flags( uint32_t fcntl_flags ) { 10e880: 55 push %ebp <== NOT EXECUTED 10e881: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e883: 56 push %esi <== NOT EXECUTED 10e884: 53 push %ebx <== NOT EXECUTED 10e885: 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 ); 10e888: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e88b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e88d: 83 e0 03 and $0x3,%eax <== NOT EXECUTED 10e890: 50 push %eax <== NOT EXECUTED 10e891: 68 e0 89 11 00 push $0x1189e0 <== NOT EXECUTED 10e896: e8 a5 13 00 00 call 10fc40 <== NOT EXECUTED 10e89b: 89 c6 mov %eax,%esi <== NOT EXECUTED /* * Everything else is single bits */ flags |= 10e89d: 58 pop %eax <== NOT EXECUTED 10e89e: 5a pop %edx <== NOT EXECUTED 10e89f: 83 e3 fc and $0xfffffffc,%ebx <== NOT EXECUTED 10e8a2: 53 push %ebx <== NOT EXECUTED 10e8a3: 68 20 8a 11 00 push $0x118a20 <== NOT EXECUTED 10e8a8: e8 4f 13 00 00 call 10fbfc <== NOT EXECUTED 10e8ad: 09 f0 or %esi,%eax <== NOT EXECUTED rtems_assoc_local_by_remote_bitfield(status_flags_assoc, fcntl_flags); return flags; } 10e8af: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e8b2: 5b pop %ebx <== NOT EXECUTED 10e8b3: 5e pop %esi <== NOT EXECUTED 10e8b4: c9 leave <== NOT EXECUTED 10e8b5: c3 ret <== NOT EXECUTED 0010e76c : */ void rtems_libio_free( rtems_libio_t *iop ) { 10e76c: 55 push %ebp <== NOT EXECUTED 10e76d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e76f: 53 push %ebx <== NOT EXECUTED 10e770: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e773: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10e776: 6a 00 push $0x0 <== NOT EXECUTED 10e778: 6a 00 push $0x0 <== NOT EXECUTED 10e77a: ff 35 78 e8 11 00 pushl 0x11e878 <== NOT EXECUTED 10e780: e8 27 bc ff ff call 10a3ac <== NOT EXECUTED if (iop->sem) 10e785: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 10e788: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e78b: 85 c0 test %eax,%eax <== NOT EXECUTED 10e78d: 74 0c je 10e79b <== NOT EXECUTED rtems_semaphore_delete(iop->sem); 10e78f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e792: 50 push %eax <== NOT EXECUTED 10e793: e8 70 bb ff ff call 10a308 <== NOT EXECUTED 10e798: 83 c4 10 add $0x10,%esp <== NOT EXECUTED iop->flags &= ~LIBIO_FLAGS_OPEN; 10e79b: 81 63 0c ff fe ff ff andl $0xfffffeff,0xc(%ebx) <== NOT EXECUTED iop->data1 = rtems_libio_iop_freelist; 10e7a2: a1 74 e8 11 00 mov 0x11e874,%eax <== NOT EXECUTED 10e7a7: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED rtems_libio_iop_freelist = iop; 10e7aa: 89 1d 74 e8 11 00 mov %ebx,0x11e874 <== NOT EXECUTED rtems_semaphore_release(rtems_libio_semaphore); 10e7b0: a1 78 e8 11 00 mov 0x11e878,%eax <== NOT EXECUTED 10e7b5: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10e7b8: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e7bb: 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); 10e7bc: e9 e3 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 e0 a3 11 00 mov 0x11a3e0,%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 1d 73 00 00 call 10e454 <== NOT EXECUTED 107137: 89 c3 mov %eax,%ebx <== NOT EXECUTED 107139: 89 1d 70 e8 11 00 mov %ebx,0x11e870 <== 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 74 e8 11 00 mov %ebx,0x11e874 <== NOT EXECUTED for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++) 10714c: 8b 0d e0 a3 11 00 mov 0x11a3e0,%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 78 e8 11 00 push $0x11e878 <== 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 bc 71 00 00 jmp 10e360 <== 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 92 38 00 00 call 10aa40 <== 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 89 38 00 00 call 10aa40 <== NOT EXECUTED 0010e6a4 : */ int rtems_libio_is_file_open( void *node_access ) { 10e6a4: 55 push %ebp <== NOT EXECUTED 10e6a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e6a7: 53 push %ebx <== NOT EXECUTED 10e6a8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e6ab: 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 ); 10e6ae: 6a 00 push $0x0 <== NOT EXECUTED 10e6b0: 6a 00 push $0x0 <== NOT EXECUTED 10e6b2: ff 35 78 e8 11 00 pushl 0x11e878 <== NOT EXECUTED 10e6b8: e8 ef 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++){ 10e6bd: 8b 15 70 e8 11 00 mov 0x11e870,%edx <== NOT EXECUTED 10e6c3: 8b 0d e0 a3 11 00 mov 0x11a3e0,%ecx <== NOT EXECUTED 10e6c9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e6cc: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10e6ce: 74 17 je 10e6e7 <== NOT EXECUTED 10e6d0: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e6d2: eb 03 jmp 10e6d7 <== NOT EXECUTED 10e6d4: 83 c2 34 add $0x34,%edx <== NOT EXECUTED if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) { 10e6d7: f6 42 0d 01 testb $0x1,0xd(%edx) <== NOT EXECUTED 10e6db: 74 05 je 10e6e2 <== NOT EXECUTED /* * Check if this node is under the file system that we * are trying to dismount. */ if ( iop->pathinfo.node_access == node_access ) { 10e6dd: 39 5a 10 cmp %ebx,0x10(%edx) <== NOT EXECUTED 10e6e0: 74 1e je 10e700 <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10e6e2: 40 inc %eax <== NOT EXECUTED 10e6e3: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10e6e5: 72 ed jb 10e6d4 <== NOT EXECUTED 10e6e7: 31 db xor %ebx,%ebx <== NOT EXECUTED break; } } } rtems_semaphore_release( rtems_libio_semaphore ); 10e6e9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e6ec: ff 35 78 e8 11 00 pushl 0x11e878 <== NOT EXECUTED 10e6f2: e8 ad bd ff ff call 10a4a4 <== NOT EXECUTED return result; } 10e6f7: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e6f9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e6fc: c9 leave <== NOT EXECUTED 10e6fd: c3 ret <== NOT EXECUTED 10e6fe: 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++){ 10e700: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10e705: eb e2 jmp 10e6e9 <== NOT EXECUTED 0010e708 : */ int rtems_libio_is_open_files_in_fs( rtems_filesystem_mount_table_entry_t * fs_mt_entry ) { 10e708: 55 push %ebp <== NOT EXECUTED 10e709: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e70b: 53 push %ebx <== NOT EXECUTED 10e70c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e70f: 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 ); 10e712: 6a 00 push $0x0 <== NOT EXECUTED 10e714: 6a 00 push $0x0 <== NOT EXECUTED 10e716: ff 35 78 e8 11 00 pushl 0x11e878 <== NOT EXECUTED 10e71c: e8 8b 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++){ 10e721: 8b 15 70 e8 11 00 mov 0x11e870,%edx <== NOT EXECUTED 10e727: 8b 0d e0 a3 11 00 mov 0x11a3e0,%ecx <== NOT EXECUTED 10e72d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e730: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10e732: 74 17 je 10e74b <== NOT EXECUTED 10e734: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e736: eb 03 jmp 10e73b <== NOT EXECUTED 10e738: 83 c2 34 add $0x34,%edx <== NOT EXECUTED if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) { 10e73b: f6 42 0d 01 testb $0x1,0xd(%edx) <== NOT EXECUTED 10e73f: 74 05 je 10e746 <== 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 ) { 10e741: 39 5a 1c cmp %ebx,0x1c(%edx) <== NOT EXECUTED 10e744: 74 1e je 10e764 <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10e746: 40 inc %eax <== NOT EXECUTED 10e747: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10e749: 72 ed jb 10e738 <== NOT EXECUTED 10e74b: 31 db xor %ebx,%ebx <== NOT EXECUTED break; } } } rtems_semaphore_release( rtems_libio_semaphore ); 10e74d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e750: ff 35 78 e8 11 00 pushl 0x11e878 <== NOT EXECUTED 10e756: e8 49 bd ff ff call 10a4a4 <== NOT EXECUTED return result; } 10e75b: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e75d: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e760: c9 leave <== NOT EXECUTED 10e761: c3 ret <== NOT EXECUTED 10e762: 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++){ 10e764: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10e769: eb e2 jmp 10e74d <== NOT EXECUTED 00124edc : rtems_filesystem_freenode( &env->root_directory); free(env); } } rtems_status_code rtems_libio_set_private_env(void) { 124edc: 55 push %ebp <== NOT EXECUTED 124edd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124edf: 57 push %edi <== NOT EXECUTED 124ee0: 56 push %esi <== NOT EXECUTED 124ee1: 53 push %ebx <== NOT EXECUTED 124ee2: 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); 124ee5: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 124ee8: 50 push %eax <== NOT EXECUTED 124ee9: 6a 00 push $0x0 <== NOT EXECUTED 124eeb: 6a 00 push $0x0 <== NOT EXECUTED 124eed: e8 de 0e 00 00 call 125dd0 <== NOT EXECUTED 124ef2: 89 c3 mov %eax,%ebx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 124ef4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124ef7: 85 c0 test %eax,%eax <== NOT EXECUTED 124ef9: 0f 85 8a 00 00 00 jne 124f89 <== NOT EXECUTED /* Only for the first time a malloc is necesary */ if (rtems_current_user_env==&rtems_global_user_env) { 124eff: 81 3d ec ae 14 00 40 cmpl $0x161640,0x14aeec <== NOT EXECUTED 124f06: 16 16 00 <== NOT EXECUTED 124f09: 0f 84 85 00 00 00 je 124f94 <== NOT EXECUTED return sc; } rtems_current_user_env = tmp; }; *rtems_current_user_env = rtems_global_user_env; /* get the global values*/ 124f0f: 8b 3d ec ae 14 00 mov 0x14aeec,%edi <== NOT EXECUTED 124f15: be 40 16 16 00 mov $0x161640,%esi <== NOT EXECUTED 124f1a: b9 10 00 00 00 mov $0x10,%ecx <== NOT EXECUTED 124f1f: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED rtems_current_user_env->task_id=task_id; /* mark the local values*/ 124f21: 8b 15 ec ae 14 00 mov 0x14aeec,%edx <== NOT EXECUTED 124f27: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 124f2a: 89 02 mov %eax,(%edx) <== NOT EXECUTED /* get a clean root */ rtems_filesystem_root = THE_ROOT_FS_LOC; 124f2c: 8d 7a 14 lea 0x14(%edx),%edi <== NOT EXECUTED 124f2f: a1 2c 11 16 00 mov 0x16112c,%eax <== NOT EXECUTED 124f34: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 124f37: b1 04 mov $0x4,%cl <== NOT EXECUTED 124f39: 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); 124f3b: 6a 00 push $0x0 <== NOT EXECUTED 124f3d: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 124f40: 89 45 c8 mov %eax,-0x38(%ebp) <== NOT EXECUTED 124f43: 50 push %eax <== NOT EXECUTED 124f44: 6a 00 push $0x0 <== NOT EXECUTED 124f46: 68 03 42 14 00 push $0x144203 <== NOT EXECUTED 124f4b: e8 dc 62 fe ff call 10b22c <== NOT EXECUTED rtems_filesystem_root = loc; 124f50: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED 124f55: 8d 78 14 lea 0x14(%eax),%edi <== NOT EXECUTED 124f58: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 124f5d: 8b 75 c8 mov -0x38(%ebp),%esi <== NOT EXECUTED 124f60: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED rtems_filesystem_evaluate_path("/", 0, &loc, 0); 124f62: 6a 00 push $0x0 <== NOT EXECUTED 124f64: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 124f67: 50 push %eax <== NOT EXECUTED 124f68: 6a 00 push $0x0 <== NOT EXECUTED 124f6a: 68 03 42 14 00 push $0x144203 <== NOT EXECUTED 124f6f: e8 b8 62 fe ff call 10b22c <== NOT EXECUTED rtems_filesystem_current = loc; 124f74: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED 124f79: 8d 78 04 lea 0x4(%eax),%edi <== NOT EXECUTED 124f7c: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 124f81: 8b 75 c8 mov -0x38(%ebp),%esi <== NOT EXECUTED 124f84: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 124f86: 83 c4 20 add $0x20,%esp <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 124f89: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124f8b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124f8e: 5b pop %ebx <== NOT EXECUTED 124f8f: 5e pop %esi <== NOT EXECUTED 124f90: 5f pop %edi <== NOT EXECUTED 124f91: c9 leave <== NOT EXECUTED 124f92: c3 ret <== NOT EXECUTED 124f93: 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)); 124f94: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124f97: 6a 40 push $0x40 <== NOT EXECUTED 124f99: e8 f6 68 fe ff call 10b894 <== NOT EXECUTED 124f9e: 89 c6 mov %eax,%esi <== NOT EXECUTED if (!tmp) 124fa0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124fa3: 85 c0 test %eax,%eax <== NOT EXECUTED 124fa5: 74 29 je 124fd0 <== 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); 124fa7: 51 push %ecx <== NOT EXECUTED 124fa8: 68 d8 4d 12 00 push $0x124dd8 <== NOT EXECUTED 124fad: 68 ec ae 14 00 push $0x14aeec <== NOT EXECUTED 124fb2: 6a 00 push $0x0 <== NOT EXECUTED 124fb4: e8 cb 11 00 00 call 126184 <== NOT EXECUTED 124fb9: 89 c7 mov %eax,%edi <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) { 124fbb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124fbe: 85 c0 test %eax,%eax <== NOT EXECUTED 124fc0: 75 12 jne 124fd4 <== NOT EXECUTED * not initialized yet */ free(tmp); return sc; } rtems_current_user_env = tmp; 124fc2: 89 35 ec ae 14 00 mov %esi,0x14aeec <== NOT EXECUTED 124fc8: e9 42 ff ff ff jmp 124f0f <== NOT EXECUTED 124fcd: 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) 124fd0: b3 1a mov $0x1a,%bl <== NOT EXECUTED 124fd2: eb b5 jmp 124f89 <== 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); 124fd4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124fd7: 56 push %esi <== NOT EXECUTED 124fd8: e8 93 63 fe ff call 10b370 <== NOT EXECUTED 124fdd: 89 fb mov %edi,%ebx <== NOT EXECUTED 124fdf: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124fe2: eb a5 jmp 124f89 <== NOT EXECUTED 00124e34 : * 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) { 124e34: 55 push %ebp <== NOT EXECUTED 124e35: 89 e5 mov %esp,%ebp <== NOT EXECUTED 124e37: 53 push %ebx <== NOT EXECUTED 124e38: 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); 124e3b: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 124e3e: 50 push %eax <== NOT EXECUTED 124e3f: 6a 00 push $0x0 <== NOT EXECUTED 124e41: 6a 00 push $0x0 <== NOT EXECUTED 124e43: e8 88 0f 00 00 call 125dd0 <== NOT EXECUTED 124e48: 89 c2 mov %eax,%edx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 124e4a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124e4d: 85 c0 test %eax,%eax <== NOT EXECUTED 124e4f: 75 32 jne 124e83 <== NOT EXECUTED if (rtems_current_user_env->task_id==current_task_id) { 124e51: 8b 1d ec ae 14 00 mov 0x14aeec,%ebx <== NOT EXECUTED 124e57: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 124e59: 3b 45 f4 cmp -0xc(%ebp),%eax <== NOT EXECUTED 124e5c: 74 2e je 124e8c <== 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, 124e5e: 52 push %edx <== NOT EXECUTED 124e5f: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 124e62: 50 push %eax <== NOT EXECUTED 124e63: 68 ec ae 14 00 push $0x14aeec <== NOT EXECUTED 124e68: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 124e6b: e8 68 14 00 00 call 1262d8 <== NOT EXECUTED 124e70: 89 c2 mov %eax,%edx <== NOT EXECUTED (void*)&shared_user_env ); if (sc != RTEMS_SUCCESSFUL) 124e72: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124e75: 85 c0 test %eax,%eax <== NOT EXECUTED 124e77: 74 3b je 124eb4 <== NOT EXECUTED return RTEMS_SUCCESSFUL; bailout: /* fallback to the global env */ rtems_current_user_env = &rtems_global_user_env; 124e79: c7 05 ec ae 14 00 40 movl $0x161640,0x14aeec <== NOT EXECUTED 124e80: 16 16 00 <== NOT EXECUTED return sc; } 124e83: 89 d0 mov %edx,%eax <== NOT EXECUTED 124e85: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 124e88: c9 leave <== NOT EXECUTED 124e89: c3 ret <== NOT EXECUTED 124e8a: 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); 124e8c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124e8f: 68 ec ae 14 00 push $0x14aeec <== NOT EXECUTED 124e94: 6a 00 push $0x0 <== NOT EXECUTED 124e96: e8 a9 13 00 00 call 126244 <== NOT EXECUTED 124e9b: 89 c2 mov %eax,%edx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) return sc; 124e9d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124ea0: 85 c0 test %eax,%eax <== NOT EXECUTED 124ea2: 75 df jne 124e83 <== NOT EXECUTED free_user_env(tmp); 124ea4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 124ea7: 53 push %ebx <== NOT EXECUTED 124ea8: e8 2b ff ff ff call 124dd8 <== NOT EXECUTED 124ead: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124eb0: eb ac jmp 124e5e <== NOT EXECUTED 124eb2: 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); 124eb4: 50 push %eax <== NOT EXECUTED 124eb5: 68 d8 4d 12 00 push $0x124dd8 <== NOT EXECUTED 124eba: 68 ec ae 14 00 push $0x14aeec <== NOT EXECUTED 124ebf: 6a 00 push $0x0 <== NOT EXECUTED 124ec1: e8 be 12 00 00 call 126184 <== NOT EXECUTED 124ec6: 89 c2 mov %eax,%edx <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 124ec8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124ecb: 85 c0 test %eax,%eax <== NOT EXECUTED 124ecd: 75 aa jne 124e79 <== NOT EXECUTED goto bailout; /* the current_user_env is the same pointer that remote env */ rtems_current_user_env = shared_user_env; 124ecf: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 124ed2: a3 ec ae 14 00 mov %eax,0x14aeec <== NOT EXECUTED 124ed7: eb aa jmp 124e83 <== NOT EXECUTED 0010e664 : */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) { 10e664: 55 push %ebp <== NOT EXECUTED 10e665: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e667: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10e66a: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e66c: 83 e0 06 and $0x6,%eax <== NOT EXECUTED 10e66f: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 10e672: 74 2c je 10e6a0 <== NOT EXECUTED fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { 10e674: f6 c2 02 test $0x2,%dl <== NOT EXECUTED 10e677: 75 23 jne 10e69c <== NOT EXECUTED 10e679: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e67b: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED 10e67e: 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 ) { 10e681: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 10e684: 74 03 je 10e689 <== NOT EXECUTED fcntl_flags |= O_NONBLOCK; 10e686: 80 cc 40 or $0x40,%ah <== NOT EXECUTED } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 10e689: f6 c6 02 test $0x2,%dh <== NOT EXECUTED 10e68c: 74 03 je 10e691 <== NOT EXECUTED fcntl_flags |= O_APPEND; 10e68e: 83 c8 08 or $0x8,%eax <== NOT EXECUTED } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 10e691: 80 e6 04 and $0x4,%dh <== NOT EXECUTED 10e694: 74 03 je 10e699 <== NOT EXECUTED fcntl_flags |= O_CREAT; 10e696: 80 cc 02 or $0x2,%ah <== NOT EXECUTED } return fcntl_flags; } 10e699: c9 leave <== NOT EXECUTED 10e69a: c3 ret <== NOT EXECUTED 10e69b: 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) { 10e69c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e69e: eb e1 jmp 10e681 <== NOT EXECUTED uint32_t flags ) { uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10e6a0: b0 02 mov $0x2,%al <== NOT EXECUTED 10e6a2: eb dd jmp 10e681 <== 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 a0 10 16 00 push $0x1610a0 <== NOT EXECUTED 10b95e: e8 99 57 00 00 call 1110fc <_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 24 11 16 00 add %eax,0x161124 <== NOT EXECUTED 10b975: 11 15 28 11 16 00 adc %edx,0x161128 <== 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 a0 10 16 00 push $0x1610a0 <== NOT EXECUTED 10b99f: e8 58 57 00 00 call 1110fc <_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 1c 11 16 00 add 0x16111c,%eax <== NOT EXECUTED 10b9af: 13 15 20 11 16 00 adc 0x161120,%edx <== NOT EXECUTED 10b9b5: a3 1c 11 16 00 mov %eax,0x16111c <== NOT EXECUTED 10b9ba: 89 15 20 11 16 00 mov %edx,0x161120 <== NOT EXECUTED current_depth = s->lifetime_allocated - s->lifetime_freed; 10b9c0: 2b 05 24 11 16 00 sub 0x161124,%eax <== NOT EXECUTED if (current_depth > s->max_depth) 10b9c6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b9c9: 3b 05 18 11 16 00 cmp 0x161118,%eax <== NOT EXECUTED 10b9cf: 76 05 jbe 10b9d6 <== NOT EXECUTED s->max_depth = current_depth; 10b9d1: a3 18 11 16 00 mov %eax,0x161118 <== 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 00 11 16 00 mov $0x161100,%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 c4 3d 12 00 03 cmpl $0x3,0x123dc4 <== 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 a0 3a 12 00 push $0x123aa0 <== NOT EXECUTED 1094c8: e8 e3 46 00 00 call 10dbb0 <_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 e4 1a 12 00 mov 0x121ae4,%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 20 5e 13 00 push $0x135e20 <== NOT EXECUTED 11234d: e8 4a 48 00 00 call 116b9c <_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 78 31 00 00 call 1154f8 <_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 56 50 00 00 call 1173e0 <_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 18 12 16 00 mov 0x161218,%eax <== NOT EXECUTED 10eebd: 40 inc %eax <== NOT EXECUTED 10eebe: a3 18 12 16 00 mov %eax,0x161218 <== NOT EXECUTED #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); 10eec3: e8 f4 6a 01 00 call 1259bc <_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 ce 0e 00 00 call 10fdc0 <_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 a0 16 16 00 push $0x1616a0 <== NOT EXECUTED 10ef02: e8 a5 1c 00 00 call 110bac <_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 c8 27 00 00 call 1116d4 <_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 bc 16 16 00 mov 0x1616bc,%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 95 27 00 00 call 1116d4 <_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 87 27 00 00 call 1116d4 <_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 001158dc : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 1158dc: 55 push %ebp <== NOT EXECUTED 1158dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1158df: 53 push %ebx <== NOT EXECUTED 1158e0: 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, 1158e3: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 1158e6: 50 push %eax <== NOT EXECUTED 1158e7: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1158ea: 68 80 cd 12 00 push $0x12cd80 <== NOT EXECUTED 1158ef: e8 7c af ff ff call 110870 <_Objects_Get> <== NOT EXECUTED 1158f4: 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 ) { 1158f6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1158f9: 8b 4d f8 mov -0x8(%ebp),%ecx <== NOT EXECUTED 1158fc: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1158fe: 75 3c jne 11593c <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, 115900: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 115903: 50 push %eax <== NOT EXECUTED 115904: 68 80 cd 12 00 push $0x12cd80 <== NOT EXECUTED 115909: e8 ee aa ff ff call 1103fc <_Objects_Close> <== NOT EXECUTED &the_message_queue->Object ); _CORE_message_queue_Close( 11590e: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 115911: 6a 05 push $0x5 <== NOT EXECUTED 115913: 6a 00 push $0x0 <== NOT EXECUTED 115915: 8d 43 14 lea 0x14(%ebx),%eax <== NOT EXECUTED 115918: 50 push %eax <== NOT EXECUTED 115919: e8 ce 04 00 00 call 115dec <_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, 11591e: 58 pop %eax <== NOT EXECUTED 11591f: 5a pop %edx <== NOT EXECUTED 115920: 53 push %ebx <== NOT EXECUTED 115921: 68 80 cd 12 00 push $0x12cd80 <== NOT EXECUTED 115926: e8 11 ae ff ff call 11073c <_Objects_Free> <== NOT EXECUTED 0, /* Not used */ 0 ); } #endif _Thread_Enable_dispatch(); 11592b: e8 84 b7 ff ff call 1110b4 <_Thread_Enable_dispatch> <== NOT EXECUTED 115930: 31 c0 xor %eax,%eax <== NOT EXECUTED 115932: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115935: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 115938: c9 leave <== NOT EXECUTED 115939: c3 ret <== NOT EXECUTED 11593a: 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 ) { 11593c: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 115941: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 115944: c9 leave <== NOT EXECUTED 115945: 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 20 5e 13 00 push $0x135e20 <== NOT EXECUTED 112523: e8 74 46 00 00 call 116b9c <_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 68 30 00 00 call 1155b0 <_CORE_message_queue_Flush> <== NOT EXECUTED 112548: 89 03 mov %eax,(%ebx) <== NOT EXECUTED _Thread_Enable_dispatch(); 11254a: e8 91 4e 00 00 call 1173e0 <_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 20 5e 13 00 push $0x135e20 <== NOT EXECUTED 112583: e8 14 46 00 00 call 116b9c <_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 3a 4e 00 00 call 1173e0 <_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 20 ed 11 00 push $0x11ed20 <== NOT EXECUTED 10a090: e8 27 1b 00 00 call 10bbbc <_Objects_Name_to_id_u32> <== NOT EXECUTED 10a095: 8b 04 85 ac 85 11 00 mov 0x1185ac(,%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 00115948 : void *buffer, size_t *size, rtems_option option_set, rtems_interval timeout ) { 115948: 55 push %ebp <== NOT EXECUTED 115949: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11594b: 57 push %edi <== NOT EXECUTED 11594c: 56 push %esi <== NOT EXECUTED 11594d: 53 push %ebx <== NOT EXECUTED 11594e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 115951: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 115954: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 115957: 8b 5d 14 mov 0x14(%ebp),%ebx <== NOT EXECUTED register Message_queue_Control *the_message_queue; Objects_Locations location; bool wait; if ( !buffer ) 11595a: 85 ff test %edi,%edi <== NOT EXECUTED 11595c: 74 6e je 1159cc <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !size ) 11595e: 85 f6 test %esi,%esi <== NOT EXECUTED 115960: 74 6a je 1159cc <== 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, 115962: 51 push %ecx <== NOT EXECUTED 115963: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 115966: 50 push %eax <== NOT EXECUTED 115967: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 11596a: 68 80 cd 12 00 push $0x12cd80 <== NOT EXECUTED 11596f: e8 fc ae ff ff call 110870 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 115974: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 115977: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 11597a: 85 d2 test %edx,%edx <== NOT EXECUTED 11597c: 75 3e jne 1159bc <== NOT EXECUTED if ( _Options_Is_no_wait( option_set ) ) wait = false; else wait = true; _CORE_message_queue_Seize( 11597e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 115981: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 115984: 83 f3 01 xor $0x1,%ebx <== NOT EXECUTED 115987: 83 e3 01 and $0x1,%ebx <== NOT EXECUTED 11598a: 53 push %ebx <== NOT EXECUTED 11598b: 56 push %esi <== NOT EXECUTED 11598c: 57 push %edi <== NOT EXECUTED 11598d: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 115990: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 115993: 50 push %eax <== NOT EXECUTED 115994: e8 b7 05 00 00 call 115f50 <_CORE_message_queue_Seize> <== NOT EXECUTED buffer, size, wait, timeout ); _Thread_Enable_dispatch(); 115999: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 11599c: e8 13 b7 ff ff call 1110b4 <_Thread_Enable_dispatch> <== NOT EXECUTED return _Message_queue_Translate_core_message_queue_return_code( 1159a1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1159a4: a1 9c ca 12 00 mov 0x12ca9c,%eax <== NOT EXECUTED 1159a9: ff 70 34 pushl 0x34(%eax) <== NOT EXECUTED 1159ac: e8 63 92 ff ff call 10ec14 <_Message_queue_Translate_core_message_queue_return_code> <== NOT EXECUTED 1159b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1159b4: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1159b7: 5b pop %ebx <== NOT EXECUTED 1159b8: 5e pop %esi <== NOT EXECUTED 1159b9: 5f pop %edi <== NOT EXECUTED 1159ba: c9 leave <== NOT EXECUTED 1159bb: c3 ret <== NOT EXECUTED if ( !size ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 1159bc: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1159c1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1159c4: 5b pop %ebx <== NOT EXECUTED 1159c5: 5e pop %esi <== NOT EXECUTED 1159c6: 5f pop %edi <== NOT EXECUTED 1159c7: c9 leave <== NOT EXECUTED 1159c8: c3 ret <== NOT EXECUTED 1159c9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 1159cc: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1159d1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1159d4: 5b pop %ebx <== NOT EXECUTED 1159d5: 5e pop %esi <== NOT EXECUTED 1159d6: 5f pop %edi <== NOT EXECUTED 1159d7: c9 leave <== NOT EXECUTED 1159d8: 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 20 ed 11 00 push $0x11ed20 <== NOT EXECUTED 10a0bd: e8 a2 19 00 00 call 10ba64 <_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 93 0c 00 00 call 10ad84 <_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 ad 21 00 00 call 10c2a8 <_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 20 5e 13 00 push $0x135e20 <== NOT EXECUTED 11271d: e8 7a 44 00 00 call 116b9c <_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 a7 30 00 00 call 1157f8 <_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 85 4c 00 00 call 1173e0 <_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 0010b6bc : #include int rtems_object_api_maximum_class( uint32_t api ) { 10b6bc: 55 push %ebp <== NOT EXECUTED 10b6bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_API_maximum_class(api); } 10b6bf: c9 leave <== NOT EXECUTED int rtems_object_api_maximum_class( uint32_t api ) { return _Objects_API_maximum_class(api); 10b6c0: e9 e7 16 00 00 jmp 10cdac <_Objects_API_maximum_class> <== NOT EXECUTED 0010b6c8 : #include uint32_t rtems_object_api_minimum_class( uint32_t api ) { 10b6c8: 55 push %ebp <== NOT EXECUTED 10b6c9: 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. 10b6cb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b6ce: 48 dec %eax <== NOT EXECUTED 10b6cf: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10b6d2: 19 c0 sbb %eax,%eax <== NOT EXECUTED 10b6d4: 83 e0 02 and $0x2,%eax <== NOT EXECUTED 10b6d7: 48 dec %eax <== NOT EXECUTED if ( _Objects_Is_api_valid( api ) ) return 1; return -1; } 10b6d8: c9 leave <== NOT EXECUTED 10b6d9: c3 ret <== NOT EXECUTED 0010b6dc : const char *rtems_object_get_api_class_name( uint32_t the_api, uint32_t the_class ) { 10b6dc: 55 push %ebp <== NOT EXECUTED 10b6dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b6df: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) 10b6e2: 83 7d 08 01 cmpl $0x1,0x8(%ebp) <== NOT EXECUTED 10b6e6: 74 2c je 10b714 <== NOT EXECUTED api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) 10b6e8: 83 7d 08 02 cmpl $0x2,0x8(%ebp) <== NOT EXECUTED 10b6ec: 74 0a je 10b6f8 <== NOT EXECUTED 10b6ee: b8 d0 c4 11 00 mov $0x11c4d0,%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"; } 10b6f3: c9 leave <== NOT EXECUTED 10b6f4: c3 ret <== NOT EXECUTED 10b6f5: 8d 76 00 lea 0x0(%esi),%esi <== 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 ) 10b6f8: b8 e0 04 12 00 mov $0x1204e0,%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 ); 10b6fd: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b700: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b703: 50 push %eax <== NOT EXECUTED 10b704: e8 17 47 00 00 call 10fe20 <== NOT EXECUTED if ( class_assoc ) 10b709: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b70c: 85 c0 test %eax,%eax <== NOT EXECUTED 10b70e: 74 0c je 10b71c <== NOT EXECUTED return class_assoc->name; 10b710: 8b 00 mov (%eax),%eax <== NOT EXECUTED return "BAD CLASS"; } 10b712: c9 leave <== NOT EXECUTED 10b713: c3 ret <== NOT EXECUTED ) { const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) 10b714: b8 c0 04 12 00 mov $0x1204c0,%eax <== NOT EXECUTED 10b719: eb e2 jmp 10b6fd <== NOT EXECUTED 10b71b: 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 ) 10b71c: b8 d8 c4 11 00 mov $0x11c4d8,%eax <== NOT EXECUTED return class_assoc->name; return "BAD CLASS"; } 10b721: c9 leave <== NOT EXECUTED 10b722: c3 ret <== NOT EXECUTED 0010b724 : }; const char *rtems_object_get_api_name( uint32_t api ) { 10b724: 55 push %ebp <== NOT EXECUTED 10b725: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b727: 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 ); 10b72a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b72d: 68 60 05 12 00 push $0x120560 <== NOT EXECUTED 10b732: e8 e9 46 00 00 call 10fe20 <== NOT EXECUTED if ( api_assoc ) 10b737: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b73a: 85 c0 test %eax,%eax <== NOT EXECUTED 10b73c: 74 06 je 10b744 <== NOT EXECUTED return api_assoc->name; 10b73e: 8b 00 mov (%eax),%eax <== NOT EXECUTED return "BAD CLASS"; } 10b740: c9 leave <== NOT EXECUTED 10b741: c3 ret <== NOT EXECUTED 10b742: 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 ) 10b744: b8 d8 c4 11 00 mov $0x11c4d8,%eax <== NOT EXECUTED return api_assoc->name; return "BAD CLASS"; } 10b749: c9 leave <== NOT EXECUTED 10b74a: c3 ret <== NOT EXECUTED 0010b78c : rtems_status_code rtems_object_get_class_information( uint32_t the_api, uint32_t the_class, rtems_object_api_class_information *info ) { 10b78c: 55 push %ebp <== NOT EXECUTED 10b78d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b78f: 56 push %esi <== NOT EXECUTED 10b790: 53 push %ebx <== NOT EXECUTED 10b791: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED uint32_t i; /* * Validate parameters and look up information structure. */ if ( !info ) 10b794: 85 f6 test %esi,%esi <== NOT EXECUTED 10b796: 74 58 je 10b7f0 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 10b798: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b79b: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b79e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b7a1: e8 22 1a 00 00 call 10d1c8 <_Objects_Get_information> <== NOT EXECUTED 10b7a6: 89 c2 mov %eax,%edx <== NOT EXECUTED if ( !obj_info ) 10b7a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b7ab: 85 c0 test %eax,%eax <== NOT EXECUTED 10b7ad: 74 4d je 10b7fc <== NOT EXECUTED return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 10b7af: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 10b7b2: 89 06 mov %eax,(%esi) <== NOT EXECUTED info->maximum_id = obj_info->maximum_id; 10b7b4: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10b7b7: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED info->auto_extend = obj_info->auto_extend; 10b7ba: 8a 42 12 mov 0x12(%edx),%al <== NOT EXECUTED 10b7bd: 88 46 0c mov %al,0xc(%esi) <== NOT EXECUTED info->maximum = obj_info->maximum; 10b7c0: 0f b7 42 10 movzwl 0x10(%edx),%eax <== NOT EXECUTED 10b7c4: 89 46 08 mov %eax,0x8(%esi) <== NOT EXECUTED for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10b7c7: 85 c0 test %eax,%eax <== NOT EXECUTED 10b7c9: 74 3d je 10b808 <== NOT EXECUTED 10b7cb: 8b 5a 1c mov 0x1c(%edx),%ebx <== NOT EXECUTED 10b7ce: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10b7d0: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 10b7d5: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if ( !obj_info->local_table[i] ) unallocated++; 10b7d8: 83 3c 93 01 cmpl $0x1,(%ebx,%edx,4) <== NOT EXECUTED 10b7dc: 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++ ) 10b7df: 42 inc %edx <== NOT EXECUTED 10b7e0: 39 d0 cmp %edx,%eax <== NOT EXECUTED 10b7e2: 73 f4 jae 10b7d8 <== NOT EXECUTED if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 10b7e4: 89 4e 10 mov %ecx,0x10(%esi) <== NOT EXECUTED 10b7e7: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10b7e9: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b7ec: 5b pop %ebx <== NOT EXECUTED 10b7ed: 5e pop %esi <== NOT EXECUTED 10b7ee: c9 leave <== NOT EXECUTED 10b7ef: c3 ret <== NOT EXECUTED uint32_t i; /* * Validate parameters and look up information structure. */ if ( !info ) 10b7f0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 10b7f5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b7f8: 5b pop %ebx <== NOT EXECUTED 10b7f9: 5e pop %esi <== NOT EXECUTED 10b7fa: c9 leave <== NOT EXECUTED 10b7fb: c3 ret <== NOT EXECUTED */ if ( !info ) return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); if ( !obj_info ) 10b7fc: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 10b801: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b804: 5b pop %ebx <== NOT EXECUTED 10b805: 5e pop %esi <== NOT EXECUTED 10b806: c9 leave <== NOT EXECUTED 10b807: 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++ ) 10b808: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10b80a: eb d8 jmp 10b7e4 <== 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 d3 1a 00 00 call 10caf8 <_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 ac b4 11 00 mov 0x11b4ac(,%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 00115a50 : char *rtems_object_get_name( Objects_Id id, size_t length, char *name ) { 115a50: 55 push %ebp <== NOT EXECUTED 115a51: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_Get_name_as_string( id, length, name ); } 115a53: c9 leave <== NOT EXECUTED Objects_Id id, size_t length, char *name ) { return _Objects_Get_name_as_string( id, length, name ); 115a54: e9 9f 09 00 00 jmp 1163f8 <_Objects_Get_name_as_string> <== NOT EXECUTED 0010b818 : #include #include #undef rtems_object_id_api_maximum uint32_t rtems_object_id_api_maximum(void) { 10b818: 55 push %ebp <== NOT EXECUTED 10b819: 89 e5 mov %esp,%ebp <== NOT EXECUTED return OBJECTS_ITRON_API; } 10b81b: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED 10b820: c9 leave <== NOT EXECUTED 10b821: c3 ret <== NOT EXECUTED 0010b824 : #include #include #undef rtems_object_id_api_minimum uint32_t rtems_object_id_api_minimum(void) { 10b824: 55 push %ebp <== NOT EXECUTED 10b825: 89 e5 mov %esp,%ebp <== NOT EXECUTED return OBJECTS_INTERNAL_API; } 10b827: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10b82c: c9 leave <== NOT EXECUTED 10b82d: c3 ret <== NOT EXECUTED 0010b830 : #undef rtems_object_id_get_api uint32_t rtems_object_id_get_api( rtems_id id ) { 10b830: 55 push %ebp <== NOT EXECUTED 10b831: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b833: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b836: c1 e8 18 shr $0x18,%eax <== NOT EXECUTED 10b839: 83 e0 07 and $0x7,%eax <== NOT EXECUTED return _Objects_Get_API( id ); } 10b83c: c9 leave <== NOT EXECUTED 10b83d: c3 ret <== NOT EXECUTED 0010b840 : #undef rtems_object_id_get_class uint32_t rtems_object_id_get_class( rtems_id id ) { 10b840: 55 push %ebp <== NOT EXECUTED 10b841: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b843: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b846: c1 e8 1b shr $0x1b,%eax <== NOT EXECUTED return _Objects_Get_class( id ); } 10b849: c9 leave <== NOT EXECUTED 10b84a: c3 ret <== NOT EXECUTED 0010b84c : #undef rtems_object_id_get_index uint32_t rtems_object_id_get_index( rtems_id id ) { 10b84c: 55 push %ebp <== NOT EXECUTED 10b84d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b84f: 0f b7 45 08 movzwl 0x8(%ebp),%eax <== NOT EXECUTED return _Objects_Get_index( id ); } 10b853: c9 leave <== NOT EXECUTED 10b854: c3 ret <== NOT EXECUTED 0010b858 : #undef rtems_object_id_get_node uint32_t rtems_object_id_get_node( rtems_id id ) { 10b858: 55 push %ebp <== NOT EXECUTED 10b859: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b85b: 0f b6 45 0a movzbl 0xa(%ebp),%eax <== NOT EXECUTED return _Objects_Get_node( id ); } 10b85f: c9 leave <== NOT EXECUTED 10b860: c3 ret <== NOT EXECUTED 0010b864 : */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) { 10b864: 55 push %ebp <== NOT EXECUTED 10b865: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b867: 57 push %edi <== NOT EXECUTED 10b868: 56 push %esi <== NOT EXECUTED 10b869: 53 push %ebx <== NOT EXECUTED 10b86a: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10b86d: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10b870: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 10b873: 85 ff test %edi,%edi <== NOT EXECUTED 10b875: 74 65 je 10b8dc <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10b877: 85 c0 test %eax,%eax <== NOT EXECUTED 10b879: 74 45 je 10b8c0 <== NOT EXECUTED 10b87b: 89 c3 mov %eax,%ebx <== NOT EXECUTED information = _Objects_Get_information_id( tmpId ); 10b87d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b880: 53 push %ebx <== NOT EXECUTED 10b881: e8 22 19 00 00 call 10d1a8 <_Objects_Get_information_id> <== NOT EXECUTED 10b886: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !information ) 10b888: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b88b: 85 c0 test %eax,%eax <== NOT EXECUTED 10b88d: 74 3d je 10b8cc <== NOT EXECUTED return RTEMS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &location ); 10b88f: 50 push %eax <== NOT EXECUTED 10b890: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10b893: 50 push %eax <== NOT EXECUTED 10b894: 53 push %ebx <== NOT EXECUTED 10b895: 56 push %esi <== NOT EXECUTED 10b896: e8 cd 1a 00 00 call 10d368 <_Objects_Get> <== NOT EXECUTED switch ( location ) { 10b89b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b89e: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10b8a1: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b8a3: 75 27 jne 10b8cc <== NOT EXECUTED case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); 10b8a5: 52 push %edx <== NOT EXECUTED 10b8a6: 57 push %edi <== NOT EXECUTED 10b8a7: 50 push %eax <== NOT EXECUTED 10b8a8: 56 push %esi <== NOT EXECUTED 10b8a9: e8 32 1d 00 00 call 10d5e0 <_Objects_Set_name> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b8ae: e8 81 24 00 00 call 10dd34 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b8b3: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b8b5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b8b8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b8bb: 5b pop %ebx <== NOT EXECUTED 10b8bc: 5e pop %esi <== NOT EXECUTED 10b8bd: 5f pop %edi <== NOT EXECUTED 10b8be: c9 leave <== NOT EXECUTED 10b8bf: c3 ret <== NOT EXECUTED Objects_Id tmpId; if ( !name ) return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10b8c0: a1 5c 28 12 00 mov 0x12285c,%eax <== NOT EXECUTED 10b8c5: 8b 58 08 mov 0x8(%eax),%ebx <== NOT EXECUTED 10b8c8: eb b3 jmp 10b87d <== NOT EXECUTED 10b8ca: 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; 10b8cc: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b8d1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b8d4: 5b pop %ebx <== NOT EXECUTED 10b8d5: 5e pop %esi <== NOT EXECUTED 10b8d6: 5f pop %edi <== NOT EXECUTED 10b8d7: c9 leave <== NOT EXECUTED 10b8d8: c3 ret <== NOT EXECUTED 10b8d9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 10b8dc: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10b8e1: eb d5 jmp 10b8b8 <== 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 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 1127e1: 40 inc %eax <== NOT EXECUTED 1127e2: a3 f8 5a 13 00 mov %eax,0x135af8 <== 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 00 59 13 00 push $0x135900 <== NOT EXECUTED 1127ef: e8 74 3e 00 00 call 116668 <_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 78 2c 00 00 call 1154ac <_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 1c 59 13 00 mov 0x13591c,%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 91 4b 00 00 call 1173e0 <_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 7f 4b 00 00 call 1173e0 <_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 00 59 13 00 push $0x135900 <== NOT EXECUTED 11287f: e8 18 43 00 00 call 116b9c <_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 38 4b 00 00 call 1173e0 <_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 00 59 13 00 push $0x135900 <== NOT EXECUTED 1128bd: e8 26 3e 00 00 call 1166e8 <_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 00 59 13 00 push $0x135900 <== NOT EXECUTED 1128ca: e8 59 41 00 00 call 116a28 <_Objects_Free> <== NOT EXECUTED 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 1128cf: e8 0c 4b 00 00 call 1173e0 <_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 00 59 13 00 push $0x135900 <== NOT EXECUTED 1128fd: e8 9a 42 00 00 call 116b9c <_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 6a 2b 00 00 call 115484 <_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 b5 4a 00 00 call 1173e0 <_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 83 4a 00 00 call 1173e0 <_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 00 59 13 00 push $0x135900 <== NOT EXECUTED 112978: e8 77 43 00 00 call 116cf4 <_Objects_Name_to_id_u32> <== NOT EXECUTED 11297d: 8b 04 85 8c a7 12 00 mov 0x12a78c(,%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 00 59 13 00 push $0x135900 <== NOT EXECUTED 11299b: e8 fc 41 00 00 call 116b9c <_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 18 4a 00 00 call 1173e0 <_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 67 2a 00 00 call 115460 <_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 df 49 00 00 call 1173e0 <_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 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 111df1: 40 inc %eax <== NOT EXECUTED 111df2: a3 f8 5a 13 00 mov %eax,0x135af8 <== 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 c0 58 13 00 push $0x1358c0 <== NOT EXECUTED 111dff: e8 64 48 00 00 call 116668 <_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 dc 58 13 00 mov 0x1358dc,%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 a5 55 00 00 call 1173e0 <_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 97 55 00 00 call 1173e0 <_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 c0 58 13 00 push $0x1358c0 <== NOT EXECUTED 111e63: e8 34 4d 00 00 call 116b9c <_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 c0 58 13 00 push $0x1358c0 <== NOT EXECUTED 111e7d: e8 66 48 00 00 call 1166e8 <_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 c0 58 13 00 push $0x1358c0 <== NOT EXECUTED 111e8a: e8 99 4b 00 00 call 116a28 <_Objects_Free> <== NOT EXECUTED _Dual_ported_memory_Free( the_port ); _Thread_Enable_dispatch(); 111e8f: e8 4c 55 00 00 call 1173e0 <_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 c0 58 13 00 push $0x1358c0 <== NOT EXECUTED 111ec7: e8 d0 4c 00 00 call 116b9c <_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 f5 54 00 00 call 1173e0 <_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 c0 58 13 00 push $0x1358c0 <== NOT EXECUTED 111f27: e8 c8 4d 00 00 call 116cf4 <_Objects_Name_to_id_u32> <== NOT EXECUTED 111f2c: 8b 04 85 8c a7 12 00 mov 0x12a78c(,%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 c0 58 13 00 push $0x1358c0 <== NOT EXECUTED 111f53: e8 44 4c 00 00 call 116b9c <_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 69 54 00 00 call 1173e0 <_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 40 59 13 00 push $0x135940 <== NOT EXECUTED 112a1f: e8 78 41 00 00 call 116b9c <_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 bc 5b 13 00 cmp 0x135bbc,%eax <== NOT EXECUTED 112a45: 74 11 je 112a58 <== NOT EXECUTED _Thread_Enable_dispatch(); 112a47: e8 94 49 00 00 call 1173e0 <_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 74 5d 00 00 call 1187d8 <_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 70 49 00 00 call 1173e0 <_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 78 27 12 00 mov 0x122778,%eax <== NOT EXECUTED 10afbc: 40 inc %eax <== NOT EXECUTED 10afbd: a3 78 27 12 00 mov %eax,0x122778 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10afc2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10afc5: 68 80 26 12 00 push $0x122680 <== NOT EXECUTED 10afca: e8 d9 1d 00 00 call 10cda8 <_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 3c 28 12 00 mov 0x12283c,%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 9c 26 12 00 mov 0x12269c,%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 96 2b 00 00 call 10dbe0 <_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 77 2b 00 00 call 10dbe0 <_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 40 59 13 00 push $0x135940 <== NOT EXECUTED 112b7b: e8 1c 40 00 00 call 116b9c <_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 40 59 13 00 push $0x135940 <== NOT EXECUTED 112b95: e8 4e 3b 00 00 call 1166e8 <_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 33 5c 00 00 call 1187d8 <_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 40 59 13 00 push $0x135940 <== NOT EXECUTED 112bb4: e8 6f 3e 00 00 call 116a28 <_Objects_Free> <== NOT EXECUTED _Rate_monotonic_Free( the_period ); _Thread_Enable_dispatch(); 112bb9: e8 22 48 00 00 call 1173e0 <_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 0012f4d4 : rtems_status_code rtems_rate_monotonic_get_statistics( Objects_Id id, rtems_rate_monotonic_period_statistics *statistics ) { 12f4d4: 55 push %ebp <== NOT EXECUTED 12f4d5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f4d7: 57 push %edi <== NOT EXECUTED 12f4d8: 56 push %esi <== NOT EXECUTED 12f4d9: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED 12f4dc: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 12f4df: 85 ff test %edi,%edi <== NOT EXECUTED 12f4e1: 74 41 je 12f524 <== 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 12f4e3: 51 push %ecx <== NOT EXECUTED 12f4e4: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 12f4e7: 50 push %eax <== NOT EXECUTED 12f4e8: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12f4eb: 68 40 18 16 00 push $0x161840 <== NOT EXECUTED 12f4f0: e8 eb 18 fe ff call 110de0 <_Objects_Get> <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 12f4f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12f4f8: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 12f4fb: 85 d2 test %edx,%edx <== NOT EXECUTED 12f4fd: 74 0d je 12f50c <== NOT EXECUTED 12f4ff: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12f504: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12f507: 5e pop %esi <== NOT EXECUTED 12f508: 5f pop %edi <== NOT EXECUTED 12f509: c9 leave <== NOT EXECUTED 12f50a: c3 ret <== NOT EXECUTED 12f50b: 90 nop <== NOT EXECUTED the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *statistics = the_period->Statistics; 12f50c: 8d 70 54 lea 0x54(%eax),%esi <== NOT EXECUTED 12f50f: b9 0e 00 00 00 mov $0xe,%ecx <== NOT EXECUTED 12f514: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 12f516: e8 b9 21 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 12f51b: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12f51d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12f520: 5e pop %esi <== NOT EXECUTED 12f521: 5f pop %edi <== NOT EXECUTED 12f522: c9 leave <== NOT EXECUTED 12f523: c3 ret <== NOT EXECUTED ) { Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 12f524: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12f529: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12f52c: 5e pop %esi <== NOT EXECUTED 12f52d: 5f pop %edi <== NOT EXECUTED 12f52e: c9 leave <== NOT EXECUTED 12f52f: c3 ret <== NOT EXECUTED 0012f530 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 12f530: 55 push %ebp <== NOT EXECUTED 12f531: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12f533: 57 push %edi <== NOT EXECUTED 12f534: 56 push %esi <== NOT EXECUTED 12f535: 53 push %ebx <== NOT EXECUTED 12f536: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 12f539: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 12f53c: 85 f6 test %esi,%esi <== NOT EXECUTED 12f53e: 74 70 je 12f5b0 <== NOT EXECUTED 12f540: 52 push %edx <== NOT EXECUTED 12f541: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 12f544: 50 push %eax <== NOT EXECUTED 12f545: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12f548: 68 40 18 16 00 push $0x161840 <== NOT EXECUTED 12f54d: e8 8e 18 fe ff call 110de0 <_Objects_Get> <== NOT EXECUTED 12f552: 89 c7 mov %eax,%edi <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 12f554: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12f557: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 12f55a: 85 c0 test %eax,%eax <== NOT EXECUTED 12f55c: 75 42 jne 12f5a0 <== NOT EXECUTED case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 12f55e: 8b 47 50 mov 0x50(%edi),%eax <== NOT EXECUTED 12f561: 85 c0 test %eax,%eax <== NOT EXECUTED 12f563: 74 03 je 12f568 <== NOT EXECUTED 12f565: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 12f568: 89 06 mov %eax,(%esi) <== NOT EXECUTED status->state = the_period->state; 12f56a: 8b 47 38 mov 0x38(%edi),%eax <== NOT EXECUTED 12f56d: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED if ( status->state == RATE_MONOTONIC_INACTIVE ) { 12f570: 85 c0 test %eax,%eax <== NOT EXECUTED 12f572: 75 4c jne 12f5c0 <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS status->since_last_period.tv_sec = 0; 12f574: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) <== NOT EXECUTED status->since_last_period.tv_nsec = 0; 12f57b: 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; 12f582: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi) <== NOT EXECUTED status->executed_since_last_period.tv_nsec = 0; 12f589: 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(); 12f590: e8 3f 21 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 12f595: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12f597: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12f59a: 5b pop %ebx <== NOT EXECUTED 12f59b: 5e pop %esi <== NOT EXECUTED 12f59c: 5f pop %edi <== NOT EXECUTED 12f59d: c9 leave <== NOT EXECUTED 12f59e: c3 ret <== NOT EXECUTED 12f59f: 90 nop <== NOT EXECUTED if ( !status ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 12f5a0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12f5a5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12f5a8: 5b pop %ebx <== NOT EXECUTED 12f5a9: 5e pop %esi <== NOT EXECUTED 12f5aa: 5f pop %edi <== NOT EXECUTED 12f5ab: c9 leave <== NOT EXECUTED 12f5ac: c3 ret <== NOT EXECUTED 12f5ad: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 12f5b0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12f5b5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12f5b8: 5b pop %ebx <== NOT EXECUTED 12f5b9: 5e pop %esi <== NOT EXECUTED 12f5ba: 5f pop %edi <== NOT EXECUTED 12f5bb: c9 leave <== NOT EXECUTED 12f5bc: c3 ret <== NOT EXECUTED 12f5bd: 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 ); 12f5c0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12f5c3: 8d 5d e8 lea -0x18(%ebp),%ebx <== NOT EXECUTED 12f5c6: 53 push %ebx <== NOT EXECUTED 12f5c7: e8 c0 70 ff ff call 12668c <_TOD_Get_uptime> <== NOT EXECUTED #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 12f5cc: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 12f5cf: 8d 46 08 lea 0x8(%esi),%eax <== NOT EXECUTED 12f5d2: 50 push %eax <== NOT EXECUTED 12f5d3: 53 push %ebx <== NOT EXECUTED 12f5d4: 8d 47 44 lea 0x44(%edi),%eax <== NOT EXECUTED 12f5d7: 50 push %eax <== NOT EXECUTED 12f5d8: e8 5f 2d fe ff call 11233c <_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( 12f5dd: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 12f5e0: 8d 46 10 lea 0x10(%esi),%eax <== NOT EXECUTED 12f5e3: 50 push %eax <== NOT EXECUTED 12f5e4: 53 push %ebx <== NOT EXECUTED 12f5e5: 68 e4 12 16 00 push $0x1612e4 <== NOT EXECUTED 12f5ea: e8 4d 2d fe ff call 11233c <_Timespec_Subtract> <== NOT EXECUTED 12f5ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12f5f2: eb 9c jmp 12f590 <== 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 80 26 12 00 push $0x122680 <== NOT EXECUTED 10b09e: e8 51 24 00 00 call 10d4f4 <_Objects_Name_to_id_u32> <== NOT EXECUTED 10b0a3: 8b 04 85 ac bc 11 00 mov 0x11bcac(,%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 80 26 12 00 push $0x122680 <== NOT EXECUTED 10b286: e8 11 21 00 00 call 10d39c <_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 3c 28 12 00 cmp 0x12283c,%eax <== NOT EXECUTED 10b2b1: 74 15 je 10b2c8 <== NOT EXECUTED _Thread_Enable_dispatch(); 10b2b3: e8 28 29 00 00 call 10dbe0 <_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 5c 28 12 00 push $0x12285c <== NOT EXECUTED 10b329: e8 86 39 00 00 call 10ecb4 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10b32e: e8 ad 28 00 00 call 10dbe0 <_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 3c 28 12 00 mov 0x12283c,%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 4f 31 00 00 call 10e4c0 <_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 53 28 00 00 call 10dbe0 <_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 3b 28 00 00 call 10dbe0 <_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 5c 28 12 00 push $0x12285c <== NOT EXECUTED 10b3d2: e8 dd 38 00 00 call 10ecb4 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10b3d7: e8 04 28 00 00 call 10dbe0 <_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 3c 28 12 00 pushl 0x12283c <== NOT EXECUTED 10b407: e8 2c 24 00 00 call 10d838 <_Thread_Clear_state> <== NOT EXECUTED 10b40c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b40f: e9 74 ff ff ff jmp 10b388 <== NOT EXECUTED 00125c2c : } } } void rtems_rate_monotonic_report_statistics( void ) { 125c2c: 55 push %ebp <== NOT EXECUTED 125c2d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125c2f: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_rate_monotonic_report_statistics_with_plugin( NULL, printk_plugin ); 125c32: 68 8c c7 10 00 push $0x10c78c <== NOT EXECUTED 125c37: 6a 00 push $0x0 <== NOT EXECUTED 125c39: e8 de fd ff ff call 125a1c <== NOT EXECUTED 125c3e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 125c41: c9 leave <== NOT EXECUTED 125c42: c3 ret <== NOT EXECUTED 00125a1c : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 125a1c: 55 push %ebp <== NOT EXECUTED 125a1d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125a1f: 57 push %edi <== NOT EXECUTED 125a20: 56 push %esi <== NOT EXECUTED 125a21: 53 push %ebx <== NOT EXECUTED 125a22: 81 ec 9c 00 00 00 sub $0x9c,%esp <== NOT EXECUTED 125a28: 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 ) 125a2b: 85 ff test %edi,%edi <== NOT EXECUTED 125a2d: 0f 84 c9 00 00 00 je 125afc <== NOT EXECUTED return; (*print)( context, "Period information by period\n" ); 125a33: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 125a36: 68 05 42 14 00 push $0x144205 <== NOT EXECUTED 125a3b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125a3e: ff d7 call *%edi <== NOT EXECUTED #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 125a40: 5e pop %esi <== NOT EXECUTED 125a41: 58 pop %eax <== NOT EXECUTED 125a42: 68 3c 42 14 00 push $0x14423c <== NOT EXECUTED 125a47: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125a4a: ff d7 call *%edi <== NOT EXECUTED #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 125a4c: 59 pop %ecx <== NOT EXECUTED 125a4d: 5b pop %ebx <== NOT EXECUTED 125a4e: 68 60 42 14 00 push $0x144260 <== NOT EXECUTED 125a53: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125a56: ff d7 call *%edi <== NOT EXECUTED Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 125a58: 58 pop %eax <== NOT EXECUTED 125a59: 5a pop %edx <== NOT EXECUTED 125a5a: 68 84 42 14 00 push $0x144284 <== NOT EXECUTED 125a5f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125a62: ff d7 call *%edi <== NOT EXECUTED #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 125a64: 5b pop %ebx <== NOT EXECUTED 125a65: 5e pop %esi <== NOT EXECUTED 125a66: 68 d0 42 14 00 push $0x1442d0 <== NOT EXECUTED 125a6b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125a6e: 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 ; 125a70: 8b 35 48 18 16 00 mov 0x161848,%esi <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; 125a76: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125a79: 3b 35 4c 18 16 00 cmp 0x16184c,%esi <== NOT EXECUTED 125a7f: 76 0c jbe 125a8d <== NOT EXECUTED 125a81: eb 79 jmp 125afc <== NOT EXECUTED 125a83: 90 nop <== NOT EXECUTED id++ ) { 125a84: 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 ; 125a85: 39 35 4c 18 16 00 cmp %esi,0x16184c <== NOT EXECUTED 125a8b: 72 6f jb 125afc <== NOT EXECUTED id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 125a8d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 125a90: 8d 45 90 lea -0x70(%ebp),%eax <== NOT EXECUTED 125a93: 50 push %eax <== NOT EXECUTED 125a94: 56 push %esi <== NOT EXECUTED 125a95: e8 3a 9a 00 00 call 12f4d4 <== NOT EXECUTED if ( status != RTEMS_SUCCESSFUL ) 125a9a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125a9d: 85 c0 test %eax,%eax <== NOT EXECUTED 125a9f: 75 e3 jne 125a84 <== NOT EXECUTED continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 125aa1: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 125aa4: 8d 55 c8 lea -0x38(%ebp),%edx <== NOT EXECUTED 125aa7: 52 push %edx <== NOT EXECUTED 125aa8: 56 push %esi <== NOT EXECUTED 125aa9: e8 82 9a 00 00 call 12f530 <== NOT EXECUTED #if defined(RTEMS_DEBUG) if ( status != RTEMS_SUCCESSFUL ) continue; #endif name[ 0 ] = '\0'; 125aae: c6 45 eb 00 movb $0x0,-0x15(%ebp) <== NOT EXECUTED if ( the_status.owner ) { 125ab2: 8b 45 c8 mov -0x38(%ebp),%eax <== NOT EXECUTED 125ab5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125ab8: 85 c0 test %eax,%eax <== NOT EXECUTED 125aba: 0f 85 54 01 00 00 jne 125c14 <== NOT EXECUTED 125ac0: 8d 5d eb lea -0x15(%ebp),%ebx <== NOT EXECUTED /* * Print part of report line that is not dependent on granularity */ (*print)( context, 125ac3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 125ac6: ff 75 94 pushl -0x6c(%ebp) <== NOT EXECUTED 125ac9: ff 75 90 pushl -0x70(%ebp) <== NOT EXECUTED 125acc: 53 push %ebx <== NOT EXECUTED 125acd: 56 push %esi <== NOT EXECUTED 125ace: 68 23 42 14 00 push $0x144223 <== NOT EXECUTED 125ad3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125ad6: ff d7 call *%edi <== NOT EXECUTED /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 125ad8: 8b 45 90 mov -0x70(%ebp),%eax <== NOT EXECUTED 125adb: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 125ade: 85 c0 test %eax,%eax <== NOT EXECUTED 125ae0: 75 22 jne 125b04 <== NOT EXECUTED (*print)( context, "\n" ); 125ae2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 125ae5: 68 f4 45 14 00 push $0x1445f4 <== NOT EXECUTED 125aea: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125aed: ff d7 call *%edi <== NOT EXECUTED 125aef: 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++ ) { 125af2: 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 ; 125af3: 39 35 4c 18 16 00 cmp %esi,0x16184c <== NOT EXECUTED 125af9: 73 92 jae 125a8d <== NOT EXECUTED 125afb: 90 nop <== NOT EXECUTED the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 125afc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 125aff: 5b pop %ebx <== NOT EXECUTED 125b00: 5e pop %esi <== NOT EXECUTED 125b01: 5f pop %edi <== NOT EXECUTED 125b02: c9 leave <== NOT EXECUTED 125b03: c3 ret <== NOT EXECUTED */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 125b04: 52 push %edx <== NOT EXECUTED 125b05: 8d 55 e0 lea -0x20(%ebp),%edx <== NOT EXECUTED 125b08: 52 push %edx <== NOT EXECUTED 125b09: 50 push %eax <== NOT EXECUTED 125b0a: 8d 45 a8 lea -0x58(%ebp),%eax <== NOT EXECUTED 125b0d: 50 push %eax <== NOT EXECUTED 125b0e: e8 1d 15 00 00 call 127030 <_Timespec_Divide_by_integer> <== NOT EXECUTED &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 125b13: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 125b16: bb d3 4d 62 10 mov $0x10624dd3,%ebx <== NOT EXECUTED 125b1b: 89 c8 mov %ecx,%eax <== NOT EXECUTED 125b1d: f7 eb imul %ebx <== NOT EXECUTED 125b1f: 89 45 88 mov %eax,-0x78(%ebp) <== NOT EXECUTED 125b22: 89 55 8c mov %edx,-0x74(%ebp) <== NOT EXECUTED 125b25: 8b 45 8c mov -0x74(%ebp),%eax <== NOT EXECUTED 125b28: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 125b2b: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 125b2e: 29 c8 sub %ecx,%eax <== NOT EXECUTED 125b30: 50 push %eax <== NOT EXECUTED 125b31: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 125b34: 8b 4d a4 mov -0x5c(%ebp),%ecx <== NOT EXECUTED 125b37: 89 c8 mov %ecx,%eax <== NOT EXECUTED 125b39: f7 eb imul %ebx <== NOT EXECUTED 125b3b: 89 45 80 mov %eax,-0x80(%ebp) <== NOT EXECUTED 125b3e: 89 55 84 mov %edx,-0x7c(%ebp) <== NOT EXECUTED 125b41: 8b 45 84 mov -0x7c(%ebp),%eax <== NOT EXECUTED 125b44: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 125b47: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 125b4a: 29 c8 sub %ecx,%eax <== NOT EXECUTED 125b4c: 50 push %eax <== NOT EXECUTED 125b4d: ff 75 a0 pushl -0x60(%ebp) <== NOT EXECUTED 125b50: 8b 4d 9c mov -0x64(%ebp),%ecx <== NOT EXECUTED 125b53: 89 c8 mov %ecx,%eax <== NOT EXECUTED 125b55: f7 eb imul %ebx <== NOT EXECUTED 125b57: 89 85 78 ff ff ff mov %eax,-0x88(%ebp) <== NOT EXECUTED 125b5d: 89 95 7c ff ff ff mov %edx,-0x84(%ebp) <== NOT EXECUTED 125b63: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax <== NOT EXECUTED 125b69: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 125b6c: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 125b6f: 29 c8 sub %ecx,%eax <== NOT EXECUTED 125b71: 50 push %eax <== NOT EXECUTED 125b72: ff 75 98 pushl -0x68(%ebp) <== NOT EXECUTED 125b75: 68 1c 43 14 00 push $0x14431c <== NOT EXECUTED 125b7a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125b7d: 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( 125b7f: 83 c4 2c add $0x2c,%esp <== NOT EXECUTED 125b82: 8d 55 e0 lea -0x20(%ebp),%edx <== NOT EXECUTED 125b85: 52 push %edx <== NOT EXECUTED 125b86: ff 75 90 pushl -0x70(%ebp) <== NOT EXECUTED 125b89: 8d 45 c0 lea -0x40(%ebp),%eax <== NOT EXECUTED 125b8c: 50 push %eax <== NOT EXECUTED 125b8d: e8 9e 14 00 00 call 127030 <_Timespec_Divide_by_integer> <== NOT EXECUTED &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 125b92: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 125b95: 89 c8 mov %ecx,%eax <== NOT EXECUTED 125b97: f7 eb imul %ebx <== NOT EXECUTED 125b99: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) <== NOT EXECUTED 125b9f: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) <== NOT EXECUTED 125ba5: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax <== NOT EXECUTED 125bab: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 125bae: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 125bb1: 29 c8 sub %ecx,%eax <== NOT EXECUTED 125bb3: 50 push %eax <== NOT EXECUTED 125bb4: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 125bb7: 8b 4d bc mov -0x44(%ebp),%ecx <== NOT EXECUTED 125bba: 89 c8 mov %ecx,%eax <== NOT EXECUTED 125bbc: f7 eb imul %ebx <== NOT EXECUTED 125bbe: 89 85 68 ff ff ff mov %eax,-0x98(%ebp) <== NOT EXECUTED 125bc4: 89 95 6c ff ff ff mov %edx,-0x94(%ebp) <== NOT EXECUTED 125bca: 8b 85 6c ff ff ff mov -0x94(%ebp),%eax <== NOT EXECUTED 125bd0: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 125bd3: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 125bd6: 29 c8 sub %ecx,%eax <== NOT EXECUTED 125bd8: 50 push %eax <== NOT EXECUTED 125bd9: ff 75 b8 pushl -0x48(%ebp) <== NOT EXECUTED 125bdc: 8b 4d b4 mov -0x4c(%ebp),%ecx <== NOT EXECUTED 125bdf: 89 c8 mov %ecx,%eax <== NOT EXECUTED 125be1: f7 eb imul %ebx <== NOT EXECUTED 125be3: 89 85 60 ff ff ff mov %eax,-0xa0(%ebp) <== NOT EXECUTED 125be9: 89 95 64 ff ff ff mov %edx,-0x9c(%ebp) <== NOT EXECUTED 125bef: 8b 85 64 ff ff ff mov -0x9c(%ebp),%eax <== NOT EXECUTED 125bf5: c1 f8 06 sar $0x6,%eax <== NOT EXECUTED 125bf8: c1 f9 1f sar $0x1f,%ecx <== NOT EXECUTED 125bfb: 29 c8 sub %ecx,%eax <== NOT EXECUTED 125bfd: 50 push %eax <== NOT EXECUTED 125bfe: ff 75 b0 pushl -0x50(%ebp) <== NOT EXECUTED 125c01: 68 3c 43 14 00 push $0x14433c <== NOT EXECUTED 125c06: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125c09: ff d7 call *%edi <== NOT EXECUTED 125c0b: 83 c4 30 add $0x30,%esp <== NOT EXECUTED 125c0e: e9 71 fe ff ff jmp 125a84 <== NOT EXECUTED 125c13: 90 nop <== NOT EXECUTED #endif name[ 0 ] = '\0'; if ( the_status.owner ) { rtems_object_get_name( the_status.owner, sizeof(name), name ); 125c14: 51 push %ecx <== NOT EXECUTED 125c15: 8d 5d eb lea -0x15(%ebp),%ebx <== NOT EXECUTED 125c18: 53 push %ebx <== NOT EXECUTED 125c19: 6a 05 push $0x5 <== NOT EXECUTED 125c1b: 50 push %eax <== NOT EXECUTED 125c1c: e8 e7 94 fe ff call 10f108 <== NOT EXECUTED 125c21: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125c24: e9 9a fe ff ff jmp 125ac3 <== NOT EXECUTED 00125c44 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 125c44: 55 push %ebp <== NOT EXECUTED 125c45: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125c47: 53 push %ebx <== NOT EXECUTED 125c48: 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 125c4b: a1 18 12 16 00 mov 0x161218,%eax <== NOT EXECUTED 125c50: 40 inc %eax <== NOT EXECUTED 125c51: a3 18 12 16 00 mov %eax,0x161218 <== 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 ; 125c56: 8b 1d 48 18 16 00 mov 0x161848,%ebx <== NOT EXECUTED id <= _Rate_monotonic_Information.maximum_id ; 125c5c: 3b 1d 4c 18 16 00 cmp 0x16184c,%ebx <== NOT EXECUTED 125c62: 77 15 ja 125c79 <== NOT EXECUTED id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 125c64: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125c67: 53 push %ebx <== NOT EXECUTED 125c68: e8 17 00 00 00 call 125c84 <== 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++ ) { 125c6d: 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 ; 125c6e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125c71: 39 1d 4c 18 16 00 cmp %ebx,0x16184c <== NOT EXECUTED 125c77: 73 eb jae 125c64 <== NOT EXECUTED /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); } 125c79: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 125c7c: c9 leave <== NOT EXECUTED } /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); 125c7d: e9 52 ba fe ff jmp 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 00125c84 : */ rtems_status_code rtems_rate_monotonic_reset_statistics( Objects_Id id ) { 125c84: 55 push %ebp <== NOT EXECUTED 125c85: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125c87: 57 push %edi <== NOT EXECUTED 125c88: 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 125c8b: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 125c8e: 50 push %eax <== NOT EXECUTED 125c8f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125c92: 68 40 18 16 00 push $0x161840 <== NOT EXECUTED 125c97: e8 44 b1 fe ff call 110de0 <_Objects_Get> <== NOT EXECUTED 125c9c: 89 c2 mov %eax,%edx <== NOT EXECUTED Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 125c9e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125ca1: 8b 45 f8 mov -0x8(%ebp),%eax <== NOT EXECUTED 125ca4: 85 c0 test %eax,%eax <== NOT EXECUTED 125ca6: 75 34 jne 125cdc <== NOT EXECUTED case OBJECTS_LOCAL: _Rate_monotonic_Reset_statistics( the_period ); 125ca8: 8d 7a 54 lea 0x54(%edx),%edi <== NOT EXECUTED 125cab: b9 38 00 00 00 mov $0x38,%ecx <== NOT EXECUTED 125cb0: 31 c0 xor %eax,%eax <== NOT EXECUTED 125cb2: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 125cb4: c7 42 5c ff ff ff 7f movl $0x7fffffff,0x5c(%edx) <== NOT EXECUTED 125cbb: c7 42 60 ff ff ff 7f movl $0x7fffffff,0x60(%edx) <== NOT EXECUTED 125cc2: c7 42 74 ff ff ff 7f movl $0x7fffffff,0x74(%edx) <== NOT EXECUTED 125cc9: c7 42 78 ff ff ff 7f movl $0x7fffffff,0x78(%edx) <== NOT EXECUTED _Thread_Enable_dispatch(); 125cd0: e8 ff b9 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 125cd5: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 125cd7: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 125cda: c9 leave <== NOT EXECUTED 125cdb: c3 ret <== NOT EXECUTED { Objects_Locations location; Rate_monotonic_Control *the_period; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 125cdc: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 125ce1: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED 125ce4: c9 leave <== NOT EXECUTED 125ce5: 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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113109: e8 de 22 00 00 call 1153ec <_API_Mutex_Lock> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 11310e: c7 04 24 80 59 13 00 movl $0x135980,(%esp) <== NOT EXECUTED 113115: e8 4e 35 00 00 call 116668 <_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 5d 30 00 00 call 116194 <_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 80 59 13 00 push $0x135980 <== NOT EXECUTED 11314a: e8 d9 38 00 00 call 116a28 <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113160: e8 cf 22 00 00 call 115434 <_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 70 49 00 00 call 117b14 <_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 9c 59 13 00 mov 0x13599c,%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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 1131d5: e8 12 22 00 00 call 1153ec <_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 80 59 13 00 push $0x135980 <== NOT EXECUTED 1131e9: e8 6e 39 00 00 call 116b5c <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113219: e8 16 22 00 00 call 115434 <_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 80 59 13 00 push $0x135980 <== NOT EXECUTED 113239: e8 aa 34 00 00 call 1166e8 <_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 80 59 13 00 push $0x135980 <== NOT EXECUTED 113246: e8 dd 37 00 00 call 116a28 <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 11326c: e8 7b 21 00 00 call 1153ec <_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 80 59 13 00 push $0x135980 <== NOT EXECUTED 113280: e8 d7 38 00 00 call 116b5c <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 1132a2: e8 8d 21 00 00 call 115434 <_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 f7 2b 00 00 call 115ebc <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 11331f: e8 c8 20 00 00 call 1153ec <_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 80 59 13 00 push $0x135980 <== NOT EXECUTED 113333: e8 24 38 00 00 call 116b5c <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113353: e8 dc 20 00 00 call 115434 <_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 3a 2d 00 00 call 1160c0 <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 1133bb: e8 2c 20 00 00 call 1153ec <_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 80 59 13 00 push $0x135980 <== NOT EXECUTED 1133cf: e8 88 37 00 00 call 116b5c <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 1133ef: e8 40 20 00 00 call 115434 <_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 fb 2c 00 00 call 116108 <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113469: e8 7e 1f 00 00 call 1153ec <_API_Mutex_Lock> <== NOT EXECUTED executing = _Thread_Executing; 11346e: a1 bc 5b 13 00 mov 0x135bbc,%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 80 59 13 00 push $0x135980 <== NOT EXECUTED 113485: e8 d2 36 00 00 call 116b5c <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 1134a7: e8 88 1f 00 00 call 115434 <_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 47 29 00 00 call 115e28 <_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 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 113503: 40 inc %eax <== NOT EXECUTED 113504: a3 f8 5a 13 00 mov %eax,0x135af8 <== 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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113512: e8 1d 1f 00 00 call 115434 <_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 f0 7b 11 00 push $0x117bf0 <== NOT EXECUTED 11353b: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 11353e: 50 push %eax <== NOT EXECUTED 11353f: e8 5c 43 00 00 call 1178a0 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED _Thread_Enable_dispatch(); 113544: e8 97 3e 00 00 call 1173e0 <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113577: e8 70 1e 00 00 call 1153ec <_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 80 59 13 00 push $0x135980 <== NOT EXECUTED 11358b: e8 cc 35 00 00 call 116b5c <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 1135ab: e8 84 1e 00 00 call 115434 <_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 a0 2f 00 00 call 116568 <_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 80 59 13 00 push $0x135980 <== NOT EXECUTED 113602: e8 ed 36 00 00 call 116cf4 <_Objects_Name_to_id_u32> <== NOT EXECUTED 113607: 8b 04 85 8c a7 12 00 mov 0x12a78c(,%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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 11362d: e8 ba 1d 00 00 call 1153ec <_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 80 59 13 00 push $0x135980 <== NOT EXECUTED 113641: e8 16 35 00 00 call 116b5c <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113667: e8 c8 1d 00 00 call 115434 <_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 e6 2c 00 00 call 11637c <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 1136b4: e8 7b 1d 00 00 call 115434 <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 1136d1: e8 5e 1d 00 00 call 115434 <_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 47 6b 00 00 call 11a24c <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113725: e8 c2 1c 00 00 call 1153ec <_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 80 59 13 00 push $0x135980 <== NOT EXECUTED 113739: e8 1e 34 00 00 call 116b5c <_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 07 28 00 00 call 115f60 <_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 b4 5b 13 00 pushl 0x135bb4 <== NOT EXECUTED 113779: e8 b6 1c 00 00 call 115434 <_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 b0 6a 00 00 call 11a24c <_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 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10a1b5: 40 inc %eax <== NOT EXECUTED 10a1b6: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10a1bb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10a1be: 68 40 e9 11 00 push $0x11e940 <== NOT EXECUTED 10a1c3: e8 a8 13 00 00 call 10b570 <_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 a0 0c 00 00 call 10aec0 <_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 40 e9 11 00 push $0x11e940 <== NOT EXECUTED 10a231: e8 fa 16 00 00 call 10b930 <_Objects_Free> <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 10a236: e8 6d 20 00 00 call 10c2a8 <_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 f2 0e 00 00 call 10b178 <_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 5c e9 11 00 mov 0x11e95c,%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 04 20 00 00 call 10c2a8 <_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 e3 1f 00 00 call 10c2a8 <_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 40 e9 11 00 push $0x11e940 <== NOT EXECUTED 10a31b: e8 44 17 00 00 call 10ba64 <_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 57 1f 00 00 call 10c2a8 <_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 4a 0b 00 00 call 10aeb4 <_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 40 e9 11 00 push $0x11e940 <== NOT EXECUTED 10a376: e8 75 12 00 00 call 10b5f0 <_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 40 e9 11 00 push $0x11e940 <== NOT EXECUTED 10a383: e8 a8 15 00 00 call 10b930 <_Objects_Free> <== NOT EXECUTED 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 10a388: e8 1b 1f 00 00 call 10c2a8 <_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 c6 0d 00 00 call 10b16c <_CORE_semaphore_Flush> <== NOT EXECUTED 10a3a6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a3a9: eb c2 jmp 10a36d <== NOT EXECUTED 00125d48 : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 125d48: 55 push %ebp <== NOT EXECUTED 125d49: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125d4b: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED * to add to the heap 125d4e: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 125d51: 50 push %eax <== NOT EXECUTED 125d52: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125d55: 68 60 11 16 00 push $0x161160 <== NOT EXECUTED 125d5a: e8 81 b0 fe ff call 110de0 <_Objects_Get> <== NOT EXECUTED register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 125d5f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125d62: 8b 55 fc mov -0x4(%ebp),%edx <== NOT EXECUTED 125d65: 85 d2 test %edx,%edx <== NOT EXECUTED 125d67: 74 07 je 125d70 <== NOT EXECUTED 125d69: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 125d6e: c9 leave <== NOT EXECUTED 125d6f: c3 ret <== NOT EXECUTED the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 125d70: f6 40 10 30 testb $0x30,0x10(%eax) <== NOT EXECUTED 125d74: 75 1a jne 125d90 <== NOT EXECUTED &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 125d76: 52 push %edx <== NOT EXECUTED 125d77: 6a 01 push $0x1 <== NOT EXECUTED 125d79: 6a 00 push $0x0 <== NOT EXECUTED 125d7b: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 125d7e: 50 push %eax <== NOT EXECUTED 125d7f: e8 04 a6 fe ff call 110388 <_CORE_semaphore_Flush> <== NOT EXECUTED 125d84: 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(); 125d87: e8 48 b9 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 125d8c: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 125d8e: c9 leave <== NOT EXECUTED 125d8f: 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( 125d90: 51 push %ecx <== NOT EXECUTED 125d91: 6a 01 push $0x1 <== NOT EXECUTED 125d93: 6a 00 push $0x0 <== NOT EXECUTED 125d95: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 125d98: 50 push %eax <== NOT EXECUTED 125d99: e8 32 a3 fe ff call 1100d0 <_CORE_mutex_Flush> <== NOT EXECUTED 125d9e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125da1: eb e4 jmp 125d87 <== 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 c0 59 13 00 push $0x1359c0 <== NOT EXECUTED 113a94: e8 5b 32 00 00 call 116cf4 <_Objects_Name_to_id_u32> <== NOT EXECUTED 113a99: 8b 04 85 8c a7 12 00 mov 0x12a78c(,%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 40 e9 11 00 push $0x11e940 <== NOT EXECUTED 10a3c5: e8 4e 16 00 00 call 10ba18 <_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 b0 0b 00 00 call 10afb8 <_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 bc ea 11 00 mov 0x11eabc,%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 bc ea 11 00 mov 0x11eabc,%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 bc ea 11 00 mov 0x11eabc,%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 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10a471: 40 inc %eax <== NOT EXECUTED 10a472: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== 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 b8 ca 10 00 push $0x10cab8 <== NOT EXECUTED 10a48f: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10a492: 50 push %eax <== NOT EXECUTED 10a493: e8 d0 22 00 00 call 10c768 <_Thread_queue_Enqueue_with_handler> <== NOT EXECUTED size_t size, 10a498: e8 0b 1e 00 00 call 10c2a8 <_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 40 e9 11 00 push $0x11e940 <== NOT EXECUTED 10a4b8: e8 a7 15 00 00 call 10ba64 <_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 d1 0c 00 00 call 10b1b8 <_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 ba 1d 00 00 call 10c2a8 <_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 47 0b 00 00 call 10b054 <_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 94 1d 00 00 call 10c2a8 <_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 00116818 : */ void rtems_shutdown_executive( uint32_t result ) { 116818: 55 push %ebp <== NOT EXECUTED 116819: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11681b: 83 ec 28 sub $0x28,%esp <== NOT EXECUTED if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 11681e: 83 3d c4 eb 11 00 04 cmpl $0x4,0x11ebc4 <== NOT EXECUTED 116825: 74 1e je 116845 <== 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( 116827: c7 05 c4 eb 11 00 04 movl $0x4,0x11ebc4 <== NOT EXECUTED 11682e: 00 00 00 <== 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 116831: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 116834: 68 e0 e9 11 00 push $0x11e9e0 <== NOT EXECUTED 116839: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 11683c: 50 push %eax <== NOT EXECUTED 11683d: e8 3e 6c ff ff call 10d480 <_CPU_Context_switch> <== NOT EXECUTED 116842: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_SHUTDOWN ); _Thread_Stop_multitasking(); } } 116845: c9 leave <== NOT EXECUTED 116846: 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 17 12 00 mov 0x12179c,%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 16 12 00 mov 0x1216d8,%eax <== NOT EXECUTED 10b1f9: 40 inc %eax <== NOT EXECUTED 10b1fa: a3 d8 16 12 00 mov %eax,0x1216d8 <== 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 0b 21 00 00 call 10d31c <_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 d8 20 00 00 call 10d31c <_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 a1 37 00 00 call 117404 <_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 98 5b 13 00 mov 0x135b98,%eax <== NOT EXECUTED 113ca0: 85 c0 test %eax,%eax <== NOT EXECUTED 113ca2: 74 1c je 113cc0 <== NOT EXECUTED 113ca4: 3b 0d bc 5b 13 00 cmp 0x135bbc,%ecx <== NOT EXECUTED 113caa: 75 14 jne 113cc0 <== NOT EXECUTED _ISR_Signals_to_thread_executing = TRUE; 113cac: c6 05 68 5c 13 00 01 movb $0x1,0x135c68 <== 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 1b 37 00 00 call 1173e0 <_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 0f 37 00 00 call 1173e0 <_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 60 10 16 00 mov $0x161060,%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 dc 12 16 00 mov 0x1612dc,%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 90 de 14 00 mov 0x14de90,%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 dc 12 16 00 pushl 0x1612dc <== 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 90 de 14 00 mov 0x14de90,%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 60 10 16 00 mov $0x161060,%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 94 de 14 00 mov %ebx,0x14de94 <== NOT EXECUTED print_handler = print; 109785: 89 35 98 de 14 00 mov %esi,0x14de98 <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 10978b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10978e: 68 a1 0e 14 00 push $0x140ea1 <== 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 b8 0e 14 00 push $0x140eb8 <== 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 e0 6f 00 00 call 11078c <== 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 94 de 14 00 00 movl $0x0,0x14de94 <== NOT EXECUTED 1097bf: 00 00 00 <== NOT EXECUTED print_handler = NULL; 1097c2: c7 05 98 de 14 00 00 movl $0x0,0x14de98 <== 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 60 10 16 00 mov $0x161060,%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 60 10 16 00 mov $0x161060,%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 80 37 12 00 push $0x123780 <== NOT EXECUTED 10b6c6: e8 15 96 00 00 call 114ce0 <== 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 b4 a4 11 00 movzbl 0x11a4b4,%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 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10a58f: e8 30 07 00 00 call 10acc4 <_API_Mutex_Lock> <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 10a594: c7 04 24 80 e9 11 00 movl $0x11e980,(%esp) <== NOT EXECUTED 10a59b: e8 d0 0f 00 00 call 10b570 <_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 80 e9 11 00 push $0x11e980 <== NOT EXECUTED 10a5e1: e8 66 1d 00 00 call 10c34c <_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 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10a615: e8 f2 06 00 00 call 10ad0c <_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 61 13 00 00 call 10b9a4 <_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 e4 12 00 00 call 10b930 <_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 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10a653: e8 b4 06 00 00 call 10ad0c <_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 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10a681: e8 86 06 00 00 call 10ad0c <_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 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10a6a5: e8 1a 06 00 00 call 10acc4 <_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 14 1c 00 00 call 10c2cc <_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 d5 12 00 00 call 10b9a4 <_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 b4 18 00 00 call 10bf8c <_Thread_Close> <== NOT EXECUTED 10a6d8: 58 pop %eax <== NOT EXECUTED 10a6d9: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 10a6dc: e8 c3 12 00 00 call 10b9a4 <_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 46 12 00 00 call 10b930 <_Objects_Free> <== NOT EXECUTED _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 10a6ea: 58 pop %eax <== NOT EXECUTED 10a6eb: ff 35 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10a6f1: e8 16 06 00 00 call 10ad0c <_API_Mutex_Unlock> <== NOT EXECUTED _Thread_Enable_dispatch(); 10a6f6: e8 ad 1b 00 00 call 10c2a8 <_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 b4 ea 11 00 pushl 0x11eab4 <== NOT EXECUTED 10a711: e8 f6 05 00 00 call 10ad0c <_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 29 12 00 mov 0x1229b4,%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 29 12 00 mov 0x1229dc,%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 e8 1e 00 00 call 10dd20 <_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 a3 1e 00 00 call 10dcfc <_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 29 12 00 mov 0x1229dc,%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 bc ea 11 00 mov 0x11eabc,%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 80 e9 11 00 push $0x11e980 <== NOT EXECUTED 10a752: e8 65 14 00 00 call 10bbbc <_Objects_Name_to_id_u32> <== NOT EXECUTED return _Status_Object_name_errors_to_status[ status ]; 10a757: 8b 04 85 ac 85 11 00 mov 0x1185ac(,%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 ea 1b 00 00 call 10c8d4 <_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 a9 1b 00 00 call 10c8b0 <_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 9b 1b 00 00 call 10c8b0 <_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 0010fce8 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 10fce8: 55 push %ebp <== NOT EXECUTED 10fce9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fceb: 57 push %edi <== NOT EXECUTED 10fcec: 56 push %esi <== NOT EXECUTED 10fced: 53 push %ebx <== NOT EXECUTED 10fcee: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fcf1: 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 ) 10fcf4: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10fcf7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10fcf9: 0f 84 31 01 00 00 je 10fe30 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 10fcff: a1 bc ea 11 00 mov 0x11eabc,%eax <== NOT EXECUTED 10fd04: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10fd07: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx <== NOT EXECUTED 10fd0d: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 10fd10: 80 78 76 01 cmpb $0x1,0x76(%eax) <== NOT EXECUTED 10fd14: 19 f6 sbb %esi,%esi <== NOT EXECUTED 10fd16: 81 e6 00 01 00 00 and $0x100,%esi <== NOT EXECUTED if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 10fd1c: 8b 50 7c mov 0x7c(%eax),%edx <== NOT EXECUTED 10fd1f: 85 d2 test %edx,%edx <== NOT EXECUTED 10fd21: 0f 85 bd 00 00 00 jne 10fde4 <== NOT EXECUTED old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 10fd27: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 10fd2a: 80 7b 08 01 cmpb $0x1,0x8(%ebx) <== NOT EXECUTED 10fd2e: 19 db sbb %ebx,%ebx <== NOT EXECUTED 10fd30: 81 e3 00 04 00 00 and $0x400,%ebx <== NOT EXECUTED old_mode |= _ISR_Get_level(); 10fd36: e8 21 d9 ff ff call 10d65c <_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; 10fd3b: 09 c3 or %eax,%ebx <== NOT EXECUTED old_mode |= _ISR_Get_level(); *previous_mode_set = old_mode; 10fd3d: 09 f3 or %esi,%ebx <== NOT EXECUTED 10fd3f: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10fd42: 89 18 mov %ebx,(%eax) <== NOT EXECUTED /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 10fd44: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) <== NOT EXECUTED 10fd4b: 74 11 je 10fd5e <== NOT EXECUTED executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE; 10fd4d: 89 f8 mov %edi,%eax <== NOT EXECUTED 10fd4f: c1 e8 08 shr $0x8,%eax <== NOT EXECUTED 10fd52: 83 f0 01 xor $0x1,%eax <== NOT EXECUTED 10fd55: 83 e0 01 and $0x1,%eax <== NOT EXECUTED 10fd58: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10fd5b: 88 42 76 mov %al,0x76(%edx) <== NOT EXECUTED if ( mask & RTEMS_TIMESLICE_MASK ) { 10fd5e: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) <== NOT EXECUTED 10fd65: 74 1e je 10fd85 <== NOT EXECUTED if ( _Modes_Is_timeslice(mode_set) ) { 10fd67: f7 c7 00 02 00 00 test $0x200,%edi <== NOT EXECUTED 10fd6d: 0f 84 81 00 00 00 je 10fdf4 <== NOT EXECUTED executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 10fd73: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 10fd76: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) <== NOT EXECUTED executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10fd7d: a1 c4 e9 11 00 mov 0x11e9c4,%eax <== NOT EXECUTED 10fd82: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 10fd85: f6 45 0c 01 testb $0x1,0xc(%ebp) <== NOT EXECUTED 10fd89: 74 09 je 10fd94 <== 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 10fd8b: f7 c7 01 00 00 00 test $0x1,%edi <== NOT EXECUTED 10fd91: 74 5d je 10fdf0 <== NOT EXECUTED 10fd93: fa cli <== NOT EXECUTED */ is_asr_enabled = FALSE; needs_asr_dispatching = FALSE; if ( mask & RTEMS_ASR_MASK ) { 10fd94: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) <== NOT EXECUTED 10fd9b: 74 31 je 10fdce <== NOT EXECUTED 10fd9d: c1 ef 0a shr $0xa,%edi <== NOT EXECUTED 10fda0: 83 f7 01 xor $0x1,%edi <== NOT EXECUTED 10fda3: 89 f8 mov %edi,%eax <== NOT EXECUTED 10fda5: 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 ) { 10fda8: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 10fdab: 38 42 08 cmp %al,0x8(%edx) <== NOT EXECUTED 10fdae: 74 1e je 10fdce <== NOT EXECUTED asr->is_enabled = is_asr_enabled; 10fdb0: 88 42 08 mov %al,0x8(%edx) <== NOT EXECUTED uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10fdb3: 9c pushf <== NOT EXECUTED 10fdb4: fa cli <== NOT EXECUTED 10fdb5: 59 pop %ecx <== NOT EXECUTED /** 10fdb6: 8b 5d f0 mov -0x10(%ebp),%ebx <== NOT EXECUTED 10fdb9: 8b 53 18 mov 0x18(%ebx),%edx <== NOT EXECUTED * This routine grows @a the_heap memory area using the size bytes which 10fdbc: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10fdbf: 89 43 18 mov %eax,0x18(%ebx) <== NOT EXECUTED * begin at @a starting_address. 10fdc2: 89 53 14 mov %edx,0x14(%ebx) <== NOT EXECUTED * 10fdc5: 51 push %ecx <== NOT EXECUTED 10fdc6: 9d popf <== NOT EXECUTED _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { 10fdc7: 8b 43 14 mov 0x14(%ebx),%eax <== NOT EXECUTED 10fdca: 85 c0 test %eax,%eax <== NOT EXECUTED 10fdcc: 75 56 jne 10fe24 <== NOT EXECUTED needs_asr_dispatching = true; executing->do_post_task_switch_extension = true; 10fdce: 31 db xor %ebx,%ebx <== NOT EXECUTED } } } if ( _System_state_Is_up(_System_state_Current) ) 10fdd0: 83 3d c4 eb 11 00 03 cmpl $0x3,0x11ebc4 <== NOT EXECUTED 10fdd7: 74 2f je 10fe08 <== NOT EXECUTED if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) _Thread_Dispatch(); 10fdd9: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10fddb: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10fdde: 5b pop %ebx <== NOT EXECUTED 10fddf: 5e pop %esi <== NOT EXECUTED 10fde0: 5f pop %edi <== NOT EXECUTED 10fde1: c9 leave <== NOT EXECUTED 10fde2: c3 ret <== NOT EXECUTED 10fde3: 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; 10fde4: 81 ce 00 02 00 00 or $0x200,%esi <== NOT EXECUTED 10fdea: e9 38 ff ff ff jmp 10fd27 <== NOT EXECUTED 10fdef: 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 10fdf0: fb sti <== NOT EXECUTED 10fdf1: eb a1 jmp 10fd94 <== NOT EXECUTED 10fdf3: 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; 10fdf4: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10fdf7: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%eax) <== NOT EXECUTED /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 10fdfe: f6 45 0c 01 testb $0x1,0xc(%ebp) <== NOT EXECUTED 10fe02: 74 90 je 10fd94 <== NOT EXECUTED 10fe04: eb 85 jmp 10fd8b <== NOT EXECUTED 10fe06: 66 90 xchg %ax,%ax <== NOT EXECUTED } } } if ( _System_state_Is_up(_System_state_Current) ) if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) 10fe08: e8 73 01 00 00 call 10ff80 <_Thread_Evaluate_mode> <== NOT EXECUTED 10fe0d: 84 c0 test %al,%al <== NOT EXECUTED 10fe0f: 75 04 jne 10fe15 <== NOT EXECUTED 10fe11: 84 db test %bl,%bl <== NOT EXECUTED 10fe13: 74 c4 je 10fdd9 <== NOT EXECUTED _Thread_Dispatch(); 10fe15: e8 32 c3 ff ff call 10c14c <_Thread_Dispatch> <== NOT EXECUTED 10fe1a: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10fe1c: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10fe1f: 5b pop %ebx <== NOT EXECUTED 10fe20: 5e pop %esi <== NOT EXECUTED 10fe21: 5f pop %edi <== NOT EXECUTED 10fe22: c9 leave <== NOT EXECUTED 10fe23: 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; 10fe24: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10fe27: c6 40 75 01 movb $0x1,0x75(%eax) <== NOT EXECUTED 10fe2b: b3 01 mov $0x1,%bl <== NOT EXECUTED 10fe2d: eb a1 jmp 10fdd0 <== NOT EXECUTED 10fe2f: 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 ) 10fe30: 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; } 10fe35: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10fe38: 5b pop %ebx <== NOT EXECUTED 10fe39: 5e pop %esi <== NOT EXECUTED 10fe3a: 5f pop %edi <== NOT EXECUTED 10fe3b: c9 leave <== NOT EXECUTED 10fe3c: c3 ret <== NOT EXECUTED 0010b108 : rtems_status_code rtems_task_restart( Objects_Id id, uint32_t argument ) { 10b108: 55 push %ebp <== NOT EXECUTED 10b109: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10b10b: 83 ec 20 sub $0x20,%esp <== NOT EXECUTED register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10b10e: 8d 45 fc lea -0x4(%ebp),%eax <== NOT EXECUTED 10b111: 50 push %eax <== NOT EXECUTED 10b112: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10b115: e8 ea 1b 00 00 call 10cd04 <_Thread_Get> <== NOT EXECUTED switch ( location ) { 10b11a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b11d: 8b 4d fc mov -0x4(%ebp),%ecx <== NOT EXECUTED 10b120: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10b122: 75 20 jne 10b144 <== NOT EXECUTED case OBJECTS_LOCAL: if ( _Thread_Restart( the_thread, NULL, argument ) ) { 10b124: 52 push %edx <== NOT EXECUTED 10b125: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10b128: 6a 00 push $0x0 <== NOT EXECUTED 10b12a: 50 push %eax <== NOT EXECUTED 10b12b: e8 f8 23 00 00 call 10d528 <_Thread_Restart> <== NOT EXECUTED 10b130: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b133: 84 c0 test %al,%al <== NOT EXECUTED 10b135: 75 15 jne 10b14c <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10b137: e8 a4 1b 00 00 call 10cce0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b13c: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b141: c9 leave <== NOT EXECUTED 10b142: c3 ret <== NOT EXECUTED 10b143: 90 nop <== NOT EXECUTED { register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); switch ( location ) { 10b144: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b149: c9 leave <== NOT EXECUTED 10b14a: c3 ret <== NOT EXECUTED 10b14b: 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(); 10b14c: e8 8f 1b 00 00 call 10cce0 <_Thread_Enable_dispatch> <== NOT EXECUTED 10b151: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b153: c9 leave <== NOT EXECUTED 10b154: 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 82 1e 00 00 call 10d7c4 <_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 15 1e 00 00 call 10d774 <_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 75 26 00 00 call 10dfe8 <_Thread_Resume> <== NOT EXECUTED _Thread_Enable_dispatch(); 10b973: e8 fc 1d 00 00 call 10d774 <_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 00125f70 : #include #include rtems_id rtems_task_self(void) { 125f70: 55 push %ebp <== NOT EXECUTED 125f71: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125f73: a1 dc 12 16 00 mov 0x1612dc,%eax <== NOT EXECUTED 125f78: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED return _Thread_Executing->Object.id; } 125f7b: c9 leave <== NOT EXECUTED 125f7c: 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 29 12 00 mov 0x1229b4,%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 29 12 00 mov 0x1229dc,%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 6f 1d 00 00 call 10dd20 <_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 2c 1d 00 00 call 10dcfc <_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 29 12 00 mov 0x1229dc,%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 72 12 00 movzbl 0x1272f4,%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 a0 1c 00 00 call 111104 <_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 3a 17 00 00 call 110bd8 <_Thread_Change_priority> <== NOT EXECUTED 10f49e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } _Thread_Enable_dispatch(); 10f4a1: e8 0e 1c 00 00 call 1110b4 <_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 cb 1a 00 00 call 10c2cc <_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 7b 25 00 00 call 10cda4 <_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 73 1a 00 00 call 10c2a8 <_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 63 1a 00 00 call 10c2a8 <_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 be 1d 00 00 call 10d7c4 <_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 51 1d 00 00 call 10d774 <_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 77 29 00 00 call 10e3ac <_Thread_Suspend> <== NOT EXECUTED _Thread_Enable_dispatch(); 10ba35: e8 3a 1d 00 00 call 10d774 <_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 00126184 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 126184: 55 push %ebp <== NOT EXECUTED 126185: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126187: 56 push %esi <== NOT EXECUTED 126188: 53 push %ebx <== NOT EXECUTED 126189: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 12618c: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 12618f: 85 db test %ebx,%ebx <== NOT EXECUTED 126191: 0f 84 a1 00 00 00 je 126238 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 126197: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12619a: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 12619d: 50 push %eax <== NOT EXECUTED 12619e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1261a1: e8 52 b5 fe ff call 1116f8 <_Thread_Get> <== NOT EXECUTED 1261a6: 89 c6 mov %eax,%esi <== NOT EXECUTED switch (location) { 1261a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1261ab: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 1261ae: 85 c0 test %eax,%eax <== NOT EXECUTED 1261b0: 75 2e jne 1261e0 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 1261b2: 8b 86 04 01 00 00 mov 0x104(%esi),%eax <== NOT EXECUTED while (tvp) { 1261b8: 85 c0 test %eax,%eax <== NOT EXECUTED 1261ba: 75 0a jne 1261c6 <== NOT EXECUTED 1261bc: eb 2e jmp 1261ec <== NOT EXECUTED 1261be: 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; 1261c0: 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) { 1261c2: 85 c0 test %eax,%eax <== NOT EXECUTED 1261c4: 74 26 je 1261ec <== NOT EXECUTED if (tvp->ptr == ptr) { 1261c6: 39 58 04 cmp %ebx,0x4(%eax) <== NOT EXECUTED 1261c9: 75 f5 jne 1261c0 <== NOT EXECUTED tvp->dtor = dtor; 1261cb: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 1261ce: 89 50 10 mov %edx,0x10(%eax) <== NOT EXECUTED _Thread_Enable_dispatch(); 1261d1: e8 fe b4 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 1261d6: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1261d8: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1261db: 5b pop %ebx <== NOT EXECUTED 1261dc: 5e pop %esi <== NOT EXECUTED 1261dd: c9 leave <== NOT EXECUTED 1261de: c3 ret <== NOT EXECUTED 1261df: 90 nop <== NOT EXECUTED if ( !ptr ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 1261e0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1261e5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1261e8: 5b pop %ebx <== NOT EXECUTED 1261e9: 5e pop %esi <== NOT EXECUTED 1261ea: c9 leave <== NOT EXECUTED 1261eb: c3 ret <== NOT EXECUTED } /* * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) 1261ec: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1261ef: 6a 14 push $0x14 <== NOT EXECUTED 1261f1: e8 12 c6 fe ff call 112808 <_Workspace_Allocate> <== NOT EXECUTED 1261f6: 89 c2 mov %eax,%edx <== NOT EXECUTED _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 1261f8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1261fb: 85 c0 test %eax,%eax <== NOT EXECUTED 1261fd: 74 2d je 12622c <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 1261ff: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 126201: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED new->ptr = ptr; 126204: 89 5a 04 mov %ebx,0x4(%edx) <== NOT EXECUTED new->dtor = dtor; 126207: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 12620a: 89 42 10 mov %eax,0x10(%edx) <== NOT EXECUTED new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 12620d: 8b 86 04 01 00 00 mov 0x104(%esi),%eax <== NOT EXECUTED 126213: 89 02 mov %eax,(%edx) <== NOT EXECUTED the_thread->task_variables = new; 126215: 89 96 04 01 00 00 mov %edx,0x104(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 12621b: e8 b4 b4 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 126220: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126222: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126225: 5b pop %ebx <== NOT EXECUTED 126226: 5e pop %esi <== NOT EXECUTED 126227: c9 leave <== NOT EXECUTED 126228: c3 ret <== NOT EXECUTED 126229: 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(); 12622c: e8 a3 b4 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 126231: b8 1a 00 00 00 mov $0x1a,%eax <== NOT EXECUTED 126236: eb ad jmp 1261e5 <== NOT EXECUTED { Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 126238: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12623d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126240: 5b pop %ebx <== NOT EXECUTED 126241: 5e pop %esi <== NOT EXECUTED 126242: c9 leave <== NOT EXECUTED 126243: c3 ret <== NOT EXECUTED 00126244 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 126244: 55 push %ebp <== NOT EXECUTED 126245: 89 e5 mov %esp,%ebp <== NOT EXECUTED 126247: 56 push %esi <== NOT EXECUTED 126248: 53 push %ebx <== NOT EXECUTED 126249: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 12624c: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 12624f: 85 db test %ebx,%ebx <== NOT EXECUTED 126251: 74 3f je 126292 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 126253: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 126256: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 126259: 50 push %eax <== NOT EXECUTED 12625a: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12625d: e8 96 b4 fe ff call 1116f8 <_Thread_Get> <== NOT EXECUTED 126262: 89 c6 mov %eax,%esi <== NOT EXECUTED switch (location) { 126264: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126267: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 12626a: 85 c0 test %eax,%eax <== NOT EXECUTED 12626c: 75 32 jne 1262a0 <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; 12626e: 8b 96 04 01 00 00 mov 0x104(%esi),%edx <== NOT EXECUTED while (tvp) { 126274: 85 d2 test %edx,%edx <== NOT EXECUTED 126276: 74 15 je 12628d <== NOT EXECUTED if (tvp->ptr == ptr) { 126278: 39 5a 04 cmp %ebx,0x4(%edx) <== NOT EXECUTED 12627b: 75 08 jne 126285 <== NOT EXECUTED 12627d: eb 4c jmp 1262cb <== NOT EXECUTED 12627f: 90 nop <== NOT EXECUTED 126280: 39 5a 04 cmp %ebx,0x4(%edx) <== NOT EXECUTED 126283: 74 27 je 1262ac <== 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; 126285: 89 d1 mov %edx,%ecx <== NOT EXECUTED } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 126287: 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) { 126289: 85 d2 test %edx,%edx <== NOT EXECUTED 12628b: 75 f3 jne 126280 <== NOT EXECUTED return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 12628d: e8 42 b4 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 126292: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126297: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12629a: 5b pop %ebx <== NOT EXECUTED 12629b: 5e pop %esi <== NOT EXECUTED 12629c: c9 leave <== NOT EXECUTED 12629d: c3 ret <== NOT EXECUTED 12629e: 66 90 xchg %ax,%ax <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); switch (location) { 1262a0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1262a5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1262a8: 5b pop %ebx <== NOT EXECUTED 1262a9: 5e pop %esi <== NOT EXECUTED 1262aa: c9 leave <== NOT EXECUTED 1262ab: c3 ret <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 1262ac: 8b 02 mov (%edx),%eax <== NOT EXECUTED 1262ae: 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 ); 1262b0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1262b3: 52 push %edx <== NOT EXECUTED 1262b4: 56 push %esi <== NOT EXECUTED 1262b5: e8 a6 00 00 00 call 126360 <_RTEMS_Tasks_Invoke_task_variable_dtor> <== NOT EXECUTED _Thread_Enable_dispatch(); 1262ba: e8 15 b4 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 1262bf: 31 c0 xor %eax,%eax <== NOT EXECUTED 1262c1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1262c4: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1262c7: 5b pop %ebx <== NOT EXECUTED 1262c8: 5e pop %esi <== NOT EXECUTED 1262c9: c9 leave <== NOT EXECUTED 1262ca: 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; 1262cb: 8b 02 mov (%edx),%eax <== NOT EXECUTED 1262cd: 89 86 04 01 00 00 mov %eax,0x104(%esi) <== NOT EXECUTED 1262d3: eb db jmp 1262b0 <== NOT EXECUTED 001262d8 : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 1262d8: 55 push %ebp <== NOT EXECUTED 1262d9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1262db: 56 push %esi <== NOT EXECUTED 1262dc: 53 push %ebx <== NOT EXECUTED 1262dd: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 1262e0: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED 1262e3: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 1262e6: 85 db test %ebx,%ebx <== NOT EXECUTED 1262e8: 74 56 je 126340 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !result ) 1262ea: 85 f6 test %esi,%esi <== NOT EXECUTED 1262ec: 74 52 je 126340 <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 1262ee: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1262f1: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 1262f4: 50 push %eax <== NOT EXECUTED 1262f5: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1262f8: e8 fb b3 fe ff call 1116f8 <_Thread_Get> <== NOT EXECUTED switch (location) { 1262fd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 126300: 8b 55 f4 mov -0xc(%ebp),%edx <== NOT EXECUTED 126303: 85 d2 test %edx,%edx <== NOT EXECUTED 126305: 75 2d jne 126334 <== NOT EXECUTED case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 126307: 8b 80 04 01 00 00 mov 0x104(%eax),%eax <== NOT EXECUTED while (tvp) { 12630d: 85 c0 test %eax,%eax <== NOT EXECUTED 12630f: 75 09 jne 12631a <== NOT EXECUTED 126311: eb 39 jmp 12634c <== NOT EXECUTED 126313: 90 nop <== NOT EXECUTED */ *result = tvp->tval; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 126314: 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) { 126316: 85 c0 test %eax,%eax <== NOT EXECUTED 126318: 74 32 je 12634c <== NOT EXECUTED if (tvp->ptr == ptr) { 12631a: 39 58 04 cmp %ebx,0x4(%eax) <== NOT EXECUTED 12631d: 75 f5 jne 126314 <== NOT EXECUTED /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 12631f: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 126322: 89 06 mov %eax,(%esi) <== NOT EXECUTED _Thread_Enable_dispatch(); 126324: e8 ab b3 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 126329: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 12632b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12632e: 5b pop %ebx <== NOT EXECUTED 12632f: 5e pop %esi <== NOT EXECUTED 126330: c9 leave <== NOT EXECUTED 126331: c3 ret <== NOT EXECUTED 126332: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !result ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 126334: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126339: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12633c: 5b pop %ebx <== NOT EXECUTED 12633d: 5e pop %esi <== NOT EXECUTED 12633e: c9 leave <== NOT EXECUTED 12633f: c3 ret <== NOT EXECUTED return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; 126340: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126345: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126348: 5b pop %ebx <== NOT EXECUTED 126349: 5e pop %esi <== NOT EXECUTED 12634a: c9 leave <== NOT EXECUTED 12634b: c3 ret <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 12634c: e8 83 b3 fe ff call 1116d4 <_Thread_Enable_dispatch> <== NOT EXECUTED 126351: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 126356: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 126359: 5b pop %ebx <== NOT EXECUTED 12635a: 5e pop %esi <== NOT EXECUTED 12635b: c9 leave <== NOT EXECUTED 12635c: 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 f8 e9 11 00 mov 0x11e9f8,%eax <== NOT EXECUTED 10a867: 40 inc %eax <== NOT EXECUTED 10a868: a3 f8 e9 11 00 mov %eax,0x11e9f8 <== 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 bc ea 11 00 pushl 0x11eabc <== NOT EXECUTED 10a87c: e8 db 22 00 00 call 10cb5c <_Thread_Set_state> <== NOT EXECUTED _Watchdog_Initialize( 10a881: a1 bc ea 11 00 mov 0x11eabc,%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 10 c1 10 00 movl $0x10c110,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 dc ea 11 00 push $0x11eadc <== NOT EXECUTED 10a8af: e8 04 29 00 00 call 10d1b8 <_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 ec 19 00 00 call 10c2a8 <_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 a7 25 00 00 call 10ce70 <_Thread_Yield_processor> <== NOT EXECUTED _Thread_Executing->Object.id, NULL ); _Watchdog_Insert_ticks( &_Thread_Executing->Timer, ticks ); } _Thread_Enable_dispatch(); 10a8c9: e8 da 19 00 00 call 10c2a8 <_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 cc 16 12 00 00 cmpb $0x0,0x1216cc <== 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 4c 17 12 00 cmp 0x12174c,%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 b8 16 12 00 mov 0x1216b8,%eax <== NOT EXECUTED 10b53b: 40 inc %eax <== NOT EXECUTED 10b53c: a3 b8 16 12 00 mov %eax,0x1216b8 <== 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 7c 17 12 00 pushl 0x12177c <== NOT EXECUTED 10b54c: e8 7f 23 00 00 call 10d8d0 <_Thread_Set_state> <== NOT EXECUTED _Watchdog_Initialize( 10b551: a1 7c 17 12 00 mov 0x12177c,%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 84 ce 10 00 movl $0x10ce84,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 4c 17 12 00 sub 0x12174c,%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 90 17 12 00 push $0x121790 <== NOT EXECUTED 10b585: e8 1e 2a 00 00 call 10dfa8 <_Watchdog_Insert> <== NOT EXECUTED ); _Watchdog_Insert_seconds( &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); 10b58a: e8 8d 1a 00 00 call 10d01c <_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 24 c8 11 00 mov %eax,0x11c824 <== NOT EXECUTED rtems_termios_raw_input_size = raw_input; 107f9f: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 107fa2: a3 28 c8 11 00 mov %eax,0x11c828 <== NOT EXECUTED rtems_termios_raw_output_size = raw_output; 107fa7: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 107faa: a3 2c c8 11 00 mov %eax,0x11c82c <== 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 2c e9 11 00 pushl 0x11e92c <== 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 64 e6 11 00 mov 0x11e664(%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 2c e9 11 00 pushl 0x11e92c <== 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 0f 15 00 00 call 10aa40 <== 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 30 e9 11 00 mov %eax,0x11e930 <== 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 34 e9 11 00 mov %edx,0x11e934 <== 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 34 e9 11 00 00 movl $0x0,0x11e934 <== 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 14 e7 11 00 mov 0x11e714,%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 e4 27 00 00 call 10aa40 <== 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 70 e6 11 00 mov 0x11e670(%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 70 e6 11 00 mov 0x11e670(%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 2c e9 11 00 mov 0x11e92c,%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 2c e9 11 00 push $0x11e92c <== 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 ac 2a 00 00 call 10aa40 <== 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 78 e6 11 00 mov 0x11e678(%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 64 e6 11 00 mov 0x11e664(%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 60 e6 11 00 mov 0x11e660(%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 2c e9 11 00 pushl 0x11e92c <== 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 34 e9 11 00 mov 0x11e934,%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 2c e9 11 00 pushl 0x11e92c <== 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 21 4e 00 00 call 10e454 <== 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 28 c8 11 00 mov 0x11c828,%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 2c c8 11 00 mov 0x11c82c,%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 24 c8 11 00 pushl 0x11c824 <== 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 34 e9 11 00 mov 0x11e934,%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 34 e9 11 00 mov %eax,0x11e934 <== NOT EXECUTED if (rtems_termios_ttyTail == NULL) 109704: 8b 35 30 e9 11 00 mov 0x11e930,%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 30 c8 11 00 movsbl 0x11c830,%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 30 c8 11 00 movsbl 0x11c830,%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 30 c8 11 00 movsbl 0x11c830,%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 30 c8 11 00 mov 0x11c830,%dl <== NOT EXECUTED 109876: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 109879: a2 30 c8 11 00 mov %al,0x11c830 <== 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 30 c8 11 00 61 movb $0x61,0x11c830 <== 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 6d 11 00 00 call 10aa40 <== 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 2c e9 11 00 pushl 0x11e92c <== 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 2c e9 11 00 pushl 0x11e92c <== 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 30 c8 11 00 movsbl 0x11c830,%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 30 c8 11 00 movsbl 0x11c830,%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 30 c8 11 00 movsbl 0x11c830,%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 30 e9 11 00 mov %eax,0x11e930 <== 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 03 24 00 00 call 10aa40 <== 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 68 e6 11 00 mov 0x11e668(%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 24 c8 11 00 mov 0x11c824,%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 74 e6 11 00 mov 0x11e674(%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 6c e6 11 00 mov 0x11e66c(%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 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 114416: e8 81 27 00 00 call 116b9c <_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 9a 43 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED 11443e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _Thread_Enable_dispatch(); 114441: e8 9a 2f 00 00 call 1173e0 <_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 0011444c : rtems_status_code rtems_timer_create( rtems_name name, Objects_Id *id ) { 11444c: 55 push %ebp <== NOT EXECUTED 11444d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11444f: 57 push %edi <== NOT EXECUTED 114450: 56 push %esi <== NOT EXECUTED 114451: 53 push %ebx <== NOT EXECUTED 114452: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114455: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 114458: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 11445b: 85 f6 test %esi,%esi <== NOT EXECUTED 11445d: 74 71 je 1144d0 <== NOT EXECUTED return RTEMS_INVALID_NAME; if ( !id ) 11445f: 85 ff test %edi,%edi <== NOT EXECUTED 114461: 0f 84 8d 00 00 00 je 1144f4 <== NOT EXECUTED /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 114467: a1 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 11446c: 40 inc %eax <== NOT EXECUTED 11446d: a3 f8 5a 13 00 mov %eax,0x135af8 <== NOT EXECUTED #ifdef __cplusplus extern "C" { #endif /** 114472: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 114475: 68 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 11447a: e8 e9 21 00 00 call 116668 <_Objects_Allocate> <== NOT EXECUTED 11447f: 89 c3 mov %eax,%ebx <== NOT EXECUTED _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { 114481: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 114484: 85 c0 test %eax,%eax <== NOT EXECUTED 114486: 74 58 je 1144e0 <== NOT EXECUTED _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_timer->the_class = TIMER_DORMANT; 114488: c7 40 38 04 00 00 00 movl $0x4,0x38(%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. * 11448f: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 114496: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 11449d: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) <== NOT EXECUTED * the heap 1144a4: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) <== NOT EXECUTED 1144ab: 8b 48 08 mov 0x8(%eax),%ecx <== NOT EXECUTED 1144ae: 0f b7 d1 movzwl %cx,%edx <== NOT EXECUTED 1144b1: a1 7c 5e 13 00 mov 0x135e7c,%eax <== NOT EXECUTED 1144b6: 89 1c 90 mov %ebx,(%eax,%edx,4) <== NOT EXECUTED 1144b9: 89 73 0c mov %esi,0xc(%ebx) <== NOT EXECUTED &_Timer_Information, &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; 1144bc: 89 0f mov %ecx,(%edi) <== NOT EXECUTED _Thread_Enable_dispatch(); 1144be: e8 1d 2f 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 1144c3: 31 c0 xor %eax,%eax <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 1144c5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1144c8: 5b pop %ebx <== NOT EXECUTED 1144c9: 5e pop %esi <== NOT EXECUTED 1144ca: 5f pop %edi <== NOT EXECUTED 1144cb: c9 leave <== NOT EXECUTED 1144cc: c3 ret <== NOT EXECUTED 1144cd: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED Objects_Id *id ) { Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 1144d0: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1144d5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1144d8: 5b pop %ebx <== NOT EXECUTED 1144d9: 5e pop %esi <== NOT EXECUTED 1144da: 5f pop %edi <== NOT EXECUTED 1144db: c9 leave <== NOT EXECUTED 1144dc: c3 ret <== NOT EXECUTED 1144dd: 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(); 1144e0: e8 fb 2e 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 1144e5: b8 05 00 00 00 mov $0x5,%eax <== NOT EXECUTED ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1144ea: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1144ed: 5b pop %ebx <== NOT EXECUTED 1144ee: 5e pop %esi <== NOT EXECUTED 1144ef: 5f pop %edi <== NOT EXECUTED 1144f0: c9 leave <== NOT EXECUTED 1144f1: c3 ret <== NOT EXECUTED 1144f2: 66 90 xchg %ax,%ax <== NOT EXECUTED Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 1144f4: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 1144f9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1144fc: 5b pop %ebx <== NOT EXECUTED 1144fd: 5e pop %esi <== NOT EXECUTED 1144fe: 5f pop %edi <== NOT EXECUTED 1144ff: c9 leave <== NOT EXECUTED 114500: 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 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 114517: e8 80 26 00 00 call 116b9c <_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 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 114531: e8 b2 21 00 00 call 1166e8 <_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 97 42 00 00 call 1187d8 <_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 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 114549: e8 da 24 00 00 call 116a28 <_Objects_Free> <== NOT EXECUTED _Timer_Free( the_timer ); _Thread_Enable_dispatch(); 11454e: e8 8d 2e 00 00 call 1173e0 <_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 0011456c : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 11456c: 55 push %ebp <== NOT EXECUTED 11456d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11456f: 57 push %edi <== NOT EXECUTED 114570: 56 push %esi <== NOT EXECUTED 114571: 53 push %ebx <== NOT EXECUTED 114572: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 114575: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 114578: 85 f6 test %esi,%esi <== NOT EXECUTED 11457a: 0f 84 98 00 00 00 je 114618 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( !routine ) 114580: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 114583: 85 ff test %edi,%edi <== NOT EXECUTED 114585: 0f 84 9d 00 00 00 je 114628 <== 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 11458b: 53 push %ebx <== NOT EXECUTED 11458c: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 11458f: 50 push %eax <== NOT EXECUTED 114590: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 114593: 68 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 114598: e8 ff 25 00 00 call 116b9c <_Objects_Get> <== NOT EXECUTED 11459d: 89 c3 mov %eax,%ebx <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 11459f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1145a2: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 1145a5: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1145a7: 75 5f jne 114608 <== NOT EXECUTED case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 1145a9: 8d 78 10 lea 0x10(%eax),%edi <== NOT EXECUTED 1145ac: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1145af: 57 push %edi <== NOT EXECUTED 1145b0: e8 23 42 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED _ISR_Disable( level ); 1145b5: 9c pushf <== NOT EXECUTED 1145b6: fa cli <== NOT EXECUTED 1145b7: 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 ) { 1145b8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1145bb: 8b 53 18 mov 0x18(%ebx),%edx <== NOT EXECUTED 1145be: 85 d2 test %edx,%edx <== NOT EXECUTED 1145c0: 75 76 jne 114638 <== 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; 1145c2: 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. * 1145c9: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 1145d0: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 1145d3: 89 53 2c mov %edx,0x2c(%ebx) <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 1145d6: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1145d9: 89 53 30 mov %edx,0x30(%ebx) <== NOT EXECUTED * the heap 1145dc: 8b 55 14 mov 0x14(%ebp),%edx <== NOT EXECUTED 1145df: 89 53 34 mov %edx,0x34(%ebx) <== NOT EXECUTED _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 1145e2: 50 push %eax <== NOT EXECUTED 1145e3: 9d popf <== 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, 1145e4: 89 73 1c mov %esi,0x1c(%ebx) <== NOT EXECUTED void *starting_address, size_t *size 1145e7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1145ea: 57 push %edi <== NOT EXECUTED 1145eb: 68 dc 5b 13 00 push $0x135bdc <== NOT EXECUTED 1145f0: e8 b3 40 00 00 call 1186a8 <_Watchdog_Insert> <== NOT EXECUTED _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 1145f5: e8 e6 2d 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 1145fa: 31 c0 xor %eax,%eax <== NOT EXECUTED 1145fc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1145ff: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 114602: 5b pop %ebx <== NOT EXECUTED 114603: 5e pop %esi <== NOT EXECUTED 114604: 5f pop %edi <== NOT EXECUTED 114605: c9 leave <== NOT EXECUTED 114606: c3 ret <== NOT EXECUTED 114607: 90 nop <== NOT EXECUTED if ( !routine ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 114608: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11460d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 114610: 5b pop %ebx <== NOT EXECUTED 114611: 5e pop %esi <== NOT EXECUTED 114612: 5f pop %edi <== NOT EXECUTED 114613: c9 leave <== NOT EXECUTED 114614: c3 ret <== NOT EXECUTED 114615: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 114618: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11461d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 114620: 5b pop %ebx <== NOT EXECUTED 114621: 5e pop %esi <== NOT EXECUTED 114622: 5f pop %edi <== NOT EXECUTED 114623: c9 leave <== NOT EXECUTED 114624: c3 ret <== NOT EXECUTED 114625: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ISR_Level level; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; if ( !routine ) 114628: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11462d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 114630: 5b pop %ebx <== NOT EXECUTED 114631: 5e pop %esi <== NOT EXECUTED 114632: 5f pop %edi <== NOT EXECUTED 114633: c9 leave <== NOT EXECUTED 114634: c3 ret <== NOT EXECUTED 114635: 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 ); 114638: 50 push %eax <== NOT EXECUTED 114639: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); 11463a: e8 a1 2d 00 00 call 1173e0 <_Thread_Enable_dispatch> <== NOT EXECUTED 11463f: 31 c0 xor %eax,%eax 114641: eb ca jmp 11460d <== 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 0c 5b 13 00 00 cmpb $0x0,0x135b0c <== 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 8c 5b 13 00 cmp 0x135b8c,%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 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 1146b5: e8 e2 24 00 00 call 116b9c <_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 06 41 00 00 call 1187d8 <_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 8c 5b 13 00 sub 0x135b8c,%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 d0 5b 13 00 push $0x135bd0 <== NOT EXECUTED 114703: e8 a0 3f 00 00 call 1186a8 <_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 d3 2c 00 00 call 1173e0 <_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 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 11474b: e8 4c 24 00 00 call 116b9c <_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 5c 2c 00 00 call 1173e0 <_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 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 1147ae: e8 41 25 00 00 call 116cf4 <_Objects_Name_to_id_u32> <== NOT EXECUTED 1147b3: 8b 04 85 8c a7 12 00 mov 0x12a78c(,%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 d4 d1 12 00 movzbl 0x12d1d4,%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 f8 5a 13 00 mov 0x135af8,%eax <== NOT EXECUTED 114a6e: 40 inc %eax <== NOT EXECUTED 114a6f: a3 f8 5a 13 00 mov %eax,0x135af8 <== NOT EXECUTED /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 114a74: 8a 1d c0 14 13 00 mov 0x1314c0,%bl <== NOT EXECUTED initialized = true; 114a7a: c6 05 c0 14 13 00 01 movb $0x1,0x1314c0 <== NOT EXECUTED _Thread_Enable_dispatch(); 114a81: e8 5a 29 00 00 call 1173e0 <_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 60 5a 13 00 64 movl $0x135a64,0x135a60 <== NOT EXECUTED 114aa7: 5a 13 00 <== NOT EXECUTED 114aaa: c7 05 64 5a 13 00 00 movl $0x0,0x135a64 <== NOT EXECUTED 114ab1: 00 00 00 <== NOT EXECUTED 114ab4: c7 05 68 5a 13 00 60 movl $0x135a60,0x135a68 <== NOT EXECUTED 114abb: 5a 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 10 5a 13 00 cmp 0x135a10,%cx <== NOT EXECUTED 114af7: 0f 86 b3 00 00 00 jbe 114bb0 <== NOT EXECUTED 114afd: 31 c0 xor %eax,%eax <== NOT EXECUTED 114aff: a3 a4 5e 13 00 mov %eax,0x135ea4 <== NOT EXECUTED 114b04: c7 05 40 5a 13 00 44 movl $0x135a44,0x135a40 <== NOT EXECUTED 114b0b: 5a 13 00 <== NOT EXECUTED 114b0e: c7 05 44 5a 13 00 00 movl $0x0,0x135a44 <== NOT EXECUTED 114b15: 00 00 00 <== NOT EXECUTED 114b18: c7 05 48 5a 13 00 40 movl $0x135a40,0x135a48 <== NOT EXECUTED 114b1f: 5a 13 00 <== NOT EXECUTED 114b22: c7 05 54 5a 13 00 58 movl $0x135a58,0x135a54 <== NOT EXECUTED 114b29: 5a 13 00 <== NOT EXECUTED 114b2c: c7 05 58 5a 13 00 00 movl $0x0,0x135a58 <== NOT EXECUTED 114b33: 00 00 00 <== NOT EXECUTED 114b36: c7 05 5c 5a 13 00 54 movl $0x135a54,0x135a5c <== NOT EXECUTED 114b3d: 5a 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 48 72 11 00 movl $0x117248,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 88 5a 13 00 00 movl $0x0,0x135a88 <== NOT EXECUTED 114b5f: 00 00 00 <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 114b62: c7 05 9c 5a 13 00 48 movl $0x117248,0x135a9c <== NOT EXECUTED 114b69: 72 11 00 <== NOT EXECUTED * @param[in] starting_address is the starting address of the memory for 114b6c: 89 0d a0 5a 13 00 mov %ecx,0x135aa0 <== NOT EXECUTED * the heap 114b72: c7 05 a4 5a 13 00 00 movl $0x0,0x135aa4 <== 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 a0 5e 13 00 c0 movl $0x114bc0,0x135ea0 <== 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 c0 14 13 00 00 movb $0x0,0x1314c0 <== 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 1c 5a 13 00 mov 0x135a1c,%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 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 1147cf: e8 c8 23 00 00 call 116b9c <_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 d6 3f 00 00 call 1187d8 <_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 dc 5b 13 00 push $0x135bdc <== NOT EXECUTED 11480a: e8 99 3e 00 00 call 1186a8 <_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 c9 2b 00 00 call 1173e0 <_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 b6 2b 00 00 call 1173e0 <_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 a0 5e 13 00 mov 0x135ea0,%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 8f 3f 00 00 call 1187d8 <_Watchdog_Remove> <== NOT EXECUTED (*_Timer_Server_schedule_operation)( the_timer ); 114849: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 11484c: ff 15 a0 5e 13 00 call *0x135ea0 <== 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 83 2b 00 00 call 1173e0 <_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 a4 5e 13 00 mov 0x135ea4,%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 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 1148a1: e8 f6 22 00 00 call 116b9c <_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 1a 3f 00 00 call 1187d8 <_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 a0 5e 13 00 call *0x135ea0 <== NOT EXECUTED _Thread_Enable_dispatch(); 1148fd: e8 de 2a 00 00 call 1173e0 <_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 c1 2a 00 00 call 1173e0 <_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 a4 5e 13 00 mov 0x135ea4,%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 0c 5b 13 00 00 cmpb $0x0,0x135b0c <== 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 8c 5b 13 00 cmp 0x135b8c,%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 60 5e 13 00 push $0x135e60 <== NOT EXECUTED 1149b1: e8 e6 21 00 00 call 116b9c <_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 0a 3e 00 00 call 1187d8 <_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 8c 5b 13 00 sub 0x135b8c,%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 a0 5e 13 00 call *0x135ea0 <== NOT EXECUTED _Thread_Enable_dispatch(); 114a00: e8 db 29 00 00 call 1173e0 <_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 50 c8 12 00 mov 0x12c850,%edx <== NOT EXECUTED 10b6f0: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10b6f3: a3 50 c8 12 00 mov %eax,0x12c850 <== NOT EXECUTED 10b6f8: 85 d2 test %edx,%edx <== NOT EXECUTED 10b6fa: 74 0b je 10b707 <== NOT EXECUTED 10b6fc: a1 d8 c9 12 00 mov 0x12c9d8,%eax <== NOT EXECUTED 10b701: 40 inc %eax <== NOT EXECUTED 10b702: a3 d8 c9 12 00 mov %eax,0x12c9d8 <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) 10b707: 83 3d 50 c8 12 00 02 cmpl $0x2,0x12c850 <== 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 a0 a1 12 00 mov 0x12a1a0,%eax <== NOT EXECUTED 10b71c: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 10b71f: e8 a4 d7 00 00 call 118ec8 <== 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 a0 a1 12 00 mov 0x12a1a0,%eax <== NOT EXECUTED 10b74c: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b74f: e8 c8 2d 01 00 call 11e51c <== 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 fc 02 01 00 call 11ba70 <== 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 8a 34 12 00 push $0x12348a <== NOT EXECUTED 10b789: a1 a0 a1 12 00 mov 0x12a1a0,%eax <== NOT EXECUTED 10b78e: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b791: e8 96 dc 00 00 call 11942c <== 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 80 3d 12 00 push $0x123d80 <== NOT EXECUTED 10b7a3: a1 a0 a1 12 00 mov 0x12a1a0,%eax <== NOT EXECUTED 10b7a8: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b7ab: e8 7c dc 00 00 call 11942c <== NOT EXECUTED 10b7b0: 89 c3 mov %eax,%ebx <== NOT EXECUTED (void) fflush(stderr); 10b7b2: 59 pop %ecx <== NOT EXECUTED 10b7b3: a1 a0 a1 12 00 mov 0x12a1a0,%eax <== NOT EXECUTED 10b7b8: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b7bb: e8 08 d7 00 00 call 118ec8 <== 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 9e 34 12 00 push $0x12349e <== 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 17 d4 00 00 call 118c18 <__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 80 37 12 00 push $0x123780 <== NOT EXECUTED 10b821: e8 ba 94 00 00 call 114ce0 <== 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 6f 34 12 00 push $0x12346f <== NOT EXECUTED 10b82f: a1 a0 a1 12 00 mov 0x12a1a0,%eax <== NOT EXECUTED 10b834: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 10b837: e8 f0 db 00 00 call 11942c <== 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 1d 02 01 00 call 11ba70 <== NOT EXECUTED 10b853: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10b856: 50 push %eax <== NOT EXECUTED 10b857: 68 7d 34 12 00 push $0x12347d <== 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 b3 34 12 00 push $0x1234b3 <== NOT EXECUTED 10b869: 6a 00 push $0x0 <== NOT EXECUTED 10b86b: e8 20 00 00 00 call 10b890 <== NOT EXECUTED abort(); 10b870: e8 6f d3 00 00 call 118be4 <== NOT EXECUTED 00123eec : /* * Extract an integer value from the database */ static int scanInt(FILE *fp, int *val) { 123eec: 55 push %ebp <== NOT EXECUTED 123eed: 89 e5 mov %esp,%ebp <== NOT EXECUTED 123eef: 57 push %edi <== NOT EXECUTED 123ef0: 56 push %esi <== NOT EXECUTED 123ef1: 53 push %ebx <== NOT EXECUTED 123ef2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 123ef5: 89 c6 mov %eax,%esi <== NOT EXECUTED 123ef7: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED 123efa: 31 db xor %ebx,%ebx <== NOT EXECUTED 123efc: c7 45 f0 ff ff ff 7f movl $0x7fffffff,-0x10(%ebp) <== NOT EXECUTED 123f03: 31 ff xor %edi,%edi <== NOT EXECUTED unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 123f05: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 123f08: 48 dec %eax <== NOT EXECUTED 123f09: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 123f0c: 85 c0 test %eax,%eax <== NOT EXECUTED 123f0e: 78 51 js 123f61 <== NOT EXECUTED 123f10: 8b 06 mov (%esi),%eax <== NOT EXECUTED 123f12: 0f b6 08 movzbl (%eax),%ecx <== NOT EXECUTED 123f15: 40 inc %eax <== NOT EXECUTED 123f16: 89 06 mov %eax,(%esi) <== NOT EXECUTED if (c == ':') 123f18: 83 f9 3a cmp $0x3a,%ecx <== NOT EXECUTED 123f1b: 74 5f je 123f7c <== NOT EXECUTED break; if (sign == 0) { 123f1d: 85 ff test %edi,%edi <== NOT EXECUTED 123f1f: 75 0e jne 123f2f <== NOT EXECUTED if (c == '-') { 123f21: 83 f9 2d cmp $0x2d,%ecx <== NOT EXECUTED 123f24: 0f 84 8a 00 00 00 je 123fb4 <== NOT EXECUTED sign = -1; limit++; continue; 123f2a: bf 01 00 00 00 mov $0x1,%edi <== NOT EXECUTED } sign = 1; } if (!isdigit(c)) 123f2f: a1 88 be 14 00 mov 0x14be88,%eax <== NOT EXECUTED 123f34: f6 04 08 04 testb $0x4,(%eax,%ecx,1) <== NOT EXECUTED 123f38: 74 6e je 123fa8 <== NOT EXECUTED return 0; d = c - '0'; if ((i > (limit / 10)) 123f3a: b8 cd cc cc cc mov $0xcccccccd,%eax <== NOT EXECUTED 123f3f: f7 65 f0 mull -0x10(%ebp) <== NOT EXECUTED 123f42: c1 ea 03 shr $0x3,%edx <== NOT EXECUTED 123f45: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 123f47: 77 5f ja 123fa8 <== NOT EXECUTED } sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; 123f49: 83 e9 30 sub $0x30,%ecx <== NOT EXECUTED if ((i > (limit / 10)) 123f4c: 39 d3 cmp %edx,%ebx <== NOT EXECUTED 123f4e: 74 48 je 123f98 <== NOT EXECUTED || ((i == (limit / 10)) && (d > (limit % 10)))) return 0; i = i * 10 + d; 123f50: 8d 04 9b lea (%ebx,%ebx,4),%eax <== NOT EXECUTED 123f53: 8d 1c 41 lea (%ecx,%eax,2),%ebx <== NOT EXECUTED unsigned int limit = INT_MAX; int sign = 0; int d; for (;;) { c = getc(fp); 123f56: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 123f59: 48 dec %eax <== NOT EXECUTED 123f5a: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 123f5d: 85 c0 test %eax,%eax <== NOT EXECUTED 123f5f: 79 af jns 123f10 <== NOT EXECUTED 123f61: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 123f64: 56 push %esi <== NOT EXECUTED 123f65: ff 35 a0 be 14 00 pushl 0x14bea0 <== NOT EXECUTED 123f6b: e8 fc 0b 01 00 call 134b6c <__srget_r> <== NOT EXECUTED 123f70: 89 c1 mov %eax,%ecx <== NOT EXECUTED 123f72: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (c == ':') 123f75: 83 f9 3a cmp $0x3a,%ecx <== NOT EXECUTED 123f78: 75 a3 jne 123f1d <== NOT EXECUTED 123f7a: 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) 123f7c: 85 ff test %edi,%edi <== NOT EXECUTED 123f7e: 74 28 je 123fa8 <== NOT EXECUTED return 0; *val = i * sign; 123f80: 0f af fb imul %ebx,%edi <== NOT EXECUTED 123f83: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 123f86: 89 38 mov %edi,(%eax) <== NOT EXECUTED 123f88: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED return 1; } 123f8d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 123f90: 5b pop %ebx <== NOT EXECUTED 123f91: 5e pop %esi <== NOT EXECUTED 123f92: 5f pop %edi <== NOT EXECUTED 123f93: c9 leave <== NOT EXECUTED 123f94: c3 ret <== NOT EXECUTED 123f95: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED sign = 1; } if (!isdigit(c)) return 0; d = c - '0'; if ((i > (limit / 10)) 123f98: 8d 04 9b lea (%ebx,%ebx,4),%eax <== NOT EXECUTED 123f9b: d1 e0 shl %eax <== NOT EXECUTED 123f9d: 8b 55 f0 mov -0x10(%ebp),%edx <== NOT EXECUTED 123fa0: 29 c2 sub %eax,%edx <== NOT EXECUTED 123fa2: 39 d1 cmp %edx,%ecx <== NOT EXECUTED 123fa4: 76 aa jbe 123f50 <== NOT EXECUTED 123fa6: 66 90 xchg %ax,%ax <== NOT EXECUTED i = i * 10 + d; } if (sign == 0) return 0; *val = i * sign; return 1; 123fa8: 31 c0 xor %eax,%eax <== NOT EXECUTED } 123faa: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 123fad: 5b pop %ebx <== NOT EXECUTED 123fae: 5e pop %esi <== NOT EXECUTED 123faf: 5f pop %edi <== NOT EXECUTED 123fb0: c9 leave <== NOT EXECUTED 123fb1: c3 ret <== NOT EXECUTED 123fb2: 66 90 xchg %ax,%ax <== NOT EXECUTED if (c == ':') break; if (sign == 0) { if (c == '-') { sign = -1; limit++; 123fb4: ff 45 f0 incl -0x10(%ebp) <== NOT EXECUTED 123fb7: bf ff ff ff ff mov $0xffffffff,%edi <== NOT EXECUTED 123fbc: e9 44 ff ff ff jmp 123f05 <== NOT EXECUTED 00123fc4 : /* * Extract a string value from the database */ static int scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag) { 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 cb mov %ecx,%ebx <== NOT EXECUTED 123fd1: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED int c; *name = *bufp; 123fd4: 8b 01 mov (%ecx),%eax <== NOT EXECUTED 123fd6: 89 02 mov %eax,(%edx) <== NOT EXECUTED 123fd8: eb 26 jmp 124000 <== NOT EXECUTED 123fda: 66 90 xchg %ax,%ax <== NOT EXECUTED for (;;) { c = getc(fp); 123fdc: 8b 06 mov (%esi),%eax <== NOT EXECUTED 123fde: 0f b6 10 movzbl (%eax),%edx <== NOT EXECUTED 123fe1: 40 inc %eax <== NOT EXECUTED 123fe2: 89 06 mov %eax,(%esi) <== NOT EXECUTED if (c == ':') { 123fe4: 83 fa 3a cmp $0x3a,%edx <== NOT EXECUTED 123fe7: 74 3b je 124024 <== NOT EXECUTED if (nlFlag) return 0; break; } if (c == '\n') { 123fe9: 83 fa 0a cmp $0xa,%edx <== NOT EXECUTED 123fec: 74 56 je 124044 <== NOT EXECUTED if (!nlFlag) return 0; break; } if (c == EOF) 123fee: 83 fa ff cmp $0xffffffff,%edx <== NOT EXECUTED 123ff1: 74 59 je 12404c <== NOT EXECUTED return 0; if (*nleft < 2) 123ff3: 83 3f 01 cmpl $0x1,(%edi) <== NOT EXECUTED 123ff6: 76 54 jbe 12404c <== NOT EXECUTED return 0; **bufp = c; 123ff8: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 123ffa: 88 10 mov %dl,(%eax) <== NOT EXECUTED ++(*bufp); 123ffc: ff 03 incl (%ebx) <== NOT EXECUTED --(*nleft); 123ffe: ff 0f decl (%edi) <== NOT EXECUTED { int c; *name = *bufp; for (;;) { c = getc(fp); 124000: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 124003: 48 dec %eax <== NOT EXECUTED 124004: 89 46 04 mov %eax,0x4(%esi) <== NOT EXECUTED 124007: 85 c0 test %eax,%eax <== NOT EXECUTED 124009: 79 d1 jns 123fdc <== NOT EXECUTED 12400b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12400e: 56 push %esi <== NOT EXECUTED 12400f: ff 35 a0 be 14 00 pushl 0x14bea0 <== NOT EXECUTED 124015: e8 52 0b 01 00 call 134b6c <__srget_r> <== NOT EXECUTED 12401a: 89 c2 mov %eax,%edx <== NOT EXECUTED 12401c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (c == ':') { 12401f: 83 fa 3a cmp $0x3a,%edx <== NOT EXECUTED 124022: 75 c5 jne 123fe9 <== NOT EXECUTED if (nlFlag) 124024: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 124027: 85 d2 test %edx,%edx <== NOT EXECUTED 124029: 75 21 jne 12404c <== NOT EXECUTED return 0; **bufp = c; ++(*bufp); --(*nleft); } **bufp = '\0'; 12402b: 8b 03 mov (%ebx),%eax <== NOT EXECUTED 12402d: c6 00 00 movb $0x0,(%eax) <== NOT EXECUTED ++(*bufp); 124030: ff 03 incl (%ebx) <== NOT EXECUTED --(*nleft); 124032: ff 0f decl (%edi) <== NOT EXECUTED 124034: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED return 1; } 124039: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12403c: 5b pop %ebx <== NOT EXECUTED 12403d: 5e pop %esi <== NOT EXECUTED 12403e: 5f pop %edi <== NOT EXECUTED 12403f: c9 leave <== NOT EXECUTED 124040: c3 ret <== NOT EXECUTED 124041: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (nlFlag) return 0; break; } if (c == '\n') { if (!nlFlag) 124044: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 124047: 85 c0 test %eax,%eax <== NOT EXECUTED 124049: 75 e0 jne 12402b <== NOT EXECUTED 12404b: 90 nop <== NOT EXECUTED --(*nleft); } **bufp = '\0'; ++(*bufp); --(*nleft); return 1; 12404c: 31 c0 xor %eax,%eax <== NOT EXECUTED } 12404e: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124051: 5b pop %ebx <== NOT EXECUTED 124052: 5e pop %esi <== NOT EXECUTED 124053: 5f pop %edi <== NOT EXECUTED 124054: c9 leave <== NOT EXECUTED 124055: c3 ret <== NOT EXECUTED 00124058 : FILE *fp, struct group *grp, char *buffer, size_t bufsize ) { 124058: 55 push %ebp <== NOT EXECUTED 124059: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12405b: 57 push %edi <== NOT EXECUTED 12405c: 56 push %esi <== NOT EXECUTED 12405d: 53 push %ebx <== NOT EXECUTED 12405e: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 124061: 89 c3 mov %eax,%ebx <== NOT EXECUTED 124063: 89 d7 mov %edx,%edi <== NOT EXECUTED 124065: 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) 124068: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED 12406b: 6a 00 push $0x0 <== NOT EXECUTED 12406d: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 124070: 50 push %eax <== NOT EXECUTED 124071: 89 f1 mov %esi,%ecx <== NOT EXECUTED 124073: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124075: e8 4a ff ff ff call 123fc4 <== NOT EXECUTED 12407a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12407d: 85 c0 test %eax,%eax <== NOT EXECUTED 12407f: 75 0b jne 12408c <== NOT EXECUTED *cp = '\0'; grp->gr_mem[memcount++] = cp + 1; } } grp->gr_mem[memcount] = NULL; return 1; 124081: 31 c0 xor %eax,%eax <== NOT EXECUTED } 124083: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 124086: 5b pop %ebx <== NOT EXECUTED 124087: 5e pop %esi <== NOT EXECUTED 124088: 5f pop %edi <== NOT EXECUTED 124089: c9 leave <== NOT EXECUTED 12408a: c3 ret <== NOT EXECUTED 12408b: 90 nop <== NOT EXECUTED { int grgid; char *grmem, *cp; int memcount; if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0) 12408c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12408f: 8d 57 04 lea 0x4(%edi),%edx <== NOT EXECUTED 124092: 6a 00 push $0x0 <== NOT EXECUTED 124094: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 124097: 50 push %eax <== NOT EXECUTED 124098: 89 f1 mov %esi,%ecx <== NOT EXECUTED 12409a: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12409c: e8 23 ff ff ff call 123fc4 <== NOT EXECUTED 1240a1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1240a4: 85 c0 test %eax,%eax <== NOT EXECUTED 1240a6: 74 d9 je 124081 <== NOT EXECUTED 1240a8: 8d 55 f0 lea -0x10(%ebp),%edx <== NOT EXECUTED 1240ab: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1240ad: e8 3a fe ff ff call 123eec <== NOT EXECUTED 1240b2: 85 c0 test %eax,%eax <== NOT EXECUTED 1240b4: 74 cb je 124081 <== NOT EXECUTED 1240b6: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1240b9: 8d 55 ec lea -0x14(%ebp),%edx <== NOT EXECUTED 1240bc: 6a 01 push $0x1 <== NOT EXECUTED 1240be: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 1240c1: 50 push %eax <== NOT EXECUTED 1240c2: 89 f1 mov %esi,%ecx <== NOT EXECUTED 1240c4: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1240c6: e8 f9 fe ff ff call 123fc4 <== NOT EXECUTED 1240cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1240ce: 85 c0 test %eax,%eax <== NOT EXECUTED 1240d0: 74 af je 124081 <== 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; 1240d2: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1240d5: 66 89 47 08 mov %ax,0x8(%edi) <== NOT EXECUTED /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 1240d9: 8b 5d ec mov -0x14(%ebp),%ebx <== NOT EXECUTED 1240dc: 8a 03 mov (%ebx),%al <== NOT EXECUTED 1240de: 84 c0 test %al,%al <== NOT EXECUTED 1240e0: 74 7d je 12415f <== NOT EXECUTED 1240e2: 89 da mov %ebx,%edx <== NOT EXECUTED 1240e4: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 1240e9: eb 08 jmp 1240f3 <== NOT EXECUTED 1240eb: 90 nop <== NOT EXECUTED 1240ec: 42 inc %edx <== NOT EXECUTED 1240ed: 8a 02 mov (%edx),%al <== NOT EXECUTED 1240ef: 84 c0 test %al,%al <== NOT EXECUTED 1240f1: 74 09 je 1240fc <== NOT EXECUTED if(*cp == ',') 1240f3: 3c 2c cmp $0x2c,%al <== NOT EXECUTED 1240f5: 75 f5 jne 1240ec <== NOT EXECUTED memcount++; 1240f7: 41 inc %ecx <== NOT EXECUTED 1240f8: eb f2 jmp 1240ec <== NOT EXECUTED 1240fa: 66 90 xchg %ax,%ax <== NOT EXECUTED grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 1240fc: 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)) 124103: 39 45 08 cmp %eax,0x8(%ebp) <== NOT EXECUTED 124106: 0f 82 75 ff ff ff jb 124081 <== NOT EXECUTED return 0; grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15); 12410c: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 12410f: 83 c0 0f add $0xf,%eax <== NOT EXECUTED 124112: 83 e0 f0 and $0xfffffff0,%eax <== NOT EXECUTED 124115: 89 47 0c mov %eax,0xc(%edi) <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; 124118: 89 18 mov %ebx,(%eax) <== NOT EXECUTED for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 12411a: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 12411d: 8a 02 mov (%edx),%al <== NOT EXECUTED 12411f: 84 c0 test %al,%al <== NOT EXECUTED 124121: 74 43 je 124166 <== NOT EXECUTED 124123: 42 inc %edx <== NOT EXECUTED 124124: b9 01 00 00 00 mov $0x1,%ecx <== NOT EXECUTED 124129: eb 08 jmp 124133 <== NOT EXECUTED 12412b: 90 nop <== NOT EXECUTED 12412c: 8a 02 mov (%edx),%al <== NOT EXECUTED 12412e: 42 inc %edx <== NOT EXECUTED 12412f: 84 c0 test %al,%al <== NOT EXECUTED 124131: 74 11 je 124144 <== NOT EXECUTED if(*cp == ',') { 124133: 3c 2c cmp $0x2c,%al <== NOT EXECUTED 124135: 75 f5 jne 12412c <== NOT EXECUTED *cp = '\0'; 124137: c6 42 ff 00 movb $0x0,-0x1(%edx) <== NOT EXECUTED grp->gr_mem[memcount++] = cp + 1; 12413b: 8b 47 0c mov 0xc(%edi),%eax <== NOT EXECUTED 12413e: 89 14 88 mov %edx,(%eax,%ecx,4) <== NOT EXECUTED 124141: 41 inc %ecx <== NOT EXECUTED 124142: eb e8 jmp 12412c <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 124144: 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; 12414b: 8b 47 0c mov 0xc(%edi),%eax <== NOT EXECUTED 12414e: c7 04 10 00 00 00 00 movl $0x0,(%eax,%edx,1) <== NOT EXECUTED 124155: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 12415a: e9 24 ff ff ff jmp 124083 <== NOT EXECUTED grp->gr_gid = grgid; /* * Determine number of members */ for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 12415f: b8 17 00 00 00 mov $0x17,%eax <== NOT EXECUTED 124164: eb 9d jmp 124103 <== NOT EXECUTED /* * Fill in pointer array */ grp->gr_mem[0] = grmem; for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) { 124166: ba 04 00 00 00 mov $0x4,%edx <== NOT EXECUTED 12416b: eb de jmp 12414b <== NOT EXECUTED 001241a8 : FILE *fp, struct passwd *pwd, char *buffer, size_t bufsize ) { 1241a8: 55 push %ebp <== NOT EXECUTED 1241a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1241ab: 57 push %edi <== NOT EXECUTED 1241ac: 56 push %esi <== NOT EXECUTED 1241ad: 53 push %ebx <== NOT EXECUTED 1241ae: 83 ec 24 sub $0x24,%esp <== NOT EXECUTED 1241b1: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1241b3: 89 d6 mov %edx,%esi <== NOT EXECUTED 1241b5: 89 4d e0 mov %ecx,-0x20(%ebp) <== NOT EXECUTED int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 1241b8: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 1241bb: 6a 00 push $0x0 <== NOT EXECUTED 1241bd: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 1241c0: 50 push %eax <== NOT EXECUTED 1241c1: 89 f9 mov %edi,%ecx <== NOT EXECUTED 1241c3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1241c5: e8 fa fd ff ff call 123fc4 <== NOT EXECUTED 1241ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1241cd: 85 c0 test %eax,%eax <== NOT EXECUTED 1241cf: 75 0b jne 1241dc <== 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; 1241d1: 31 c0 xor %eax,%eax <== NOT EXECUTED } 1241d3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1241d6: 5b pop %ebx <== NOT EXECUTED 1241d7: 5e pop %esi <== NOT EXECUTED 1241d8: 5f pop %edi <== NOT EXECUTED 1241d9: c9 leave <== NOT EXECUTED 1241da: c3 ret <== NOT EXECUTED 1241db: 90 nop <== NOT EXECUTED size_t bufsize ) { int pwuid, pwgid; if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0) 1241dc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1241df: 8d 56 04 lea 0x4(%esi),%edx <== NOT EXECUTED 1241e2: 6a 00 push $0x0 <== NOT EXECUTED 1241e4: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 1241e7: 50 push %eax <== NOT EXECUTED 1241e8: 89 f9 mov %edi,%ecx <== NOT EXECUTED 1241ea: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1241ec: e8 d3 fd ff ff call 123fc4 <== NOT EXECUTED 1241f1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1241f4: 85 c0 test %eax,%eax <== NOT EXECUTED 1241f6: 74 d9 je 1241d1 <== NOT EXECUTED 1241f8: 8d 55 f0 lea -0x10(%ebp),%edx <== NOT EXECUTED 1241fb: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1241fd: e8 ea fc ff ff call 123eec <== NOT EXECUTED 124202: 85 c0 test %eax,%eax <== NOT EXECUTED 124204: 74 cb je 1241d1 <== NOT EXECUTED 124206: 8d 55 ec lea -0x14(%ebp),%edx <== NOT EXECUTED 124209: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12420b: e8 dc fc ff ff call 123eec <== NOT EXECUTED 124210: 85 c0 test %eax,%eax <== NOT EXECUTED 124212: 74 bd je 1241d1 <== NOT EXECUTED 124214: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124217: 8d 56 0c lea 0xc(%esi),%edx <== NOT EXECUTED 12421a: 6a 00 push $0x0 <== NOT EXECUTED 12421c: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 12421f: 50 push %eax <== NOT EXECUTED 124220: 89 f9 mov %edi,%ecx <== NOT EXECUTED 124222: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124224: e8 9b fd ff ff call 123fc4 <== NOT EXECUTED 124229: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12422c: 85 c0 test %eax,%eax <== NOT EXECUTED 12422e: 74 a1 je 1241d1 <== NOT EXECUTED 124230: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 124233: 8d 56 10 lea 0x10(%esi),%edx <== NOT EXECUTED 124236: 6a 00 push $0x0 <== NOT EXECUTED 124238: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 12423b: 50 push %eax <== NOT EXECUTED 12423c: 89 f9 mov %edi,%ecx <== NOT EXECUTED 12423e: 89 d8 mov %ebx,%eax <== NOT EXECUTED 124240: e8 7f fd ff ff call 123fc4 <== NOT EXECUTED 124245: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124248: 85 c0 test %eax,%eax <== NOT EXECUTED 12424a: 74 85 je 1241d1 <== NOT EXECUTED 12424c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12424f: 8d 56 14 lea 0x14(%esi),%edx <== NOT EXECUTED 124252: 6a 00 push $0x0 <== NOT EXECUTED 124254: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 124257: 50 push %eax <== NOT EXECUTED 124258: 89 f9 mov %edi,%ecx <== NOT EXECUTED 12425a: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12425c: e8 63 fd ff ff call 123fc4 <== NOT EXECUTED 124261: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124264: 85 c0 test %eax,%eax <== NOT EXECUTED 124266: 0f 84 65 ff ff ff je 1241d1 <== NOT EXECUTED 12426c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12426f: 8d 56 18 lea 0x18(%esi),%edx <== NOT EXECUTED 124272: 6a 01 push $0x1 <== NOT EXECUTED 124274: 8d 45 08 lea 0x8(%ebp),%eax <== NOT EXECUTED 124277: 50 push %eax <== NOT EXECUTED 124278: 89 f9 mov %edi,%ecx <== NOT EXECUTED 12427a: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12427c: e8 43 fd ff ff call 123fc4 <== NOT EXECUTED 124281: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 124284: 85 c0 test %eax,%eax <== NOT EXECUTED 124286: 0f 84 45 ff ff ff je 1241d1 <== 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; 12428c: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 12428f: 66 89 46 08 mov %ax,0x8(%esi) <== NOT EXECUTED pwd->pw_gid = pwgid; 124293: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 124296: 66 89 46 0a mov %ax,0xa(%esi) <== NOT EXECUTED 12429a: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 12429f: e9 2f ff ff ff jmp 1241d3 <== NOT EXECUTED 00123e98 : */ int setgid( gid_t gid ) { 123e98: 55 push %ebp <== NOT EXECUTED 123e99: 89 e5 mov %esp,%ebp <== NOT EXECUTED _POSIX_types_Gid = gid; 123e9b: 8b 15 ec ae 14 00 mov 0x14aeec,%edx <== NOT EXECUTED 123ea1: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 123ea4: 66 89 42 2c mov %ax,0x2c(%edx) <== NOT EXECUTED return 0; } 123ea8: 31 c0 xor %eax,%eax <== NOT EXECUTED 123eaa: c9 leave <== NOT EXECUTED 123eab: c3 ret <== NOT EXECUTED 001243dc : return NULL; return &grent; } void setgrent(void) { 1243dc: 55 push %ebp <== NOT EXECUTED 1243dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1243df: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED init_etc_passwd_group(); 1243e2: e8 f5 fe ff ff call 1242dc <== NOT EXECUTED if (group_fp != NULL) 1243e7: a1 84 07 16 00 mov 0x160784,%eax <== NOT EXECUTED 1243ec: 85 c0 test %eax,%eax <== NOT EXECUTED 1243ee: 74 0c je 1243fc <== NOT EXECUTED fclose(group_fp); 1243f0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1243f3: 50 push %eax <== NOT EXECUTED 1243f4: e8 33 cb 00 00 call 130f2c <== NOT EXECUTED 1243f9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED group_fp = fopen("/etc/group", "r"); 1243fc: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1243ff: 68 e1 19 14 00 push $0x1419e1 <== NOT EXECUTED 124404: 68 b9 40 14 00 push $0x1440b9 <== NOT EXECUTED 124409: e8 8a d2 00 00 call 131698 <== NOT EXECUTED 12440e: a3 84 07 16 00 mov %eax,0x160784 <== NOT EXECUTED 124413: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 124416: c9 leave <== NOT EXECUTED 124417: c3 ret <== NOT EXECUTED 001245a4 : return NULL; return &pwent; } void setpwent(void) { 1245a4: 55 push %ebp <== NOT EXECUTED 1245a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1245a7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED init_etc_passwd_group(); 1245aa: e8 2d fd ff ff call 1242dc <== NOT EXECUTED if (passwd_fp != NULL) 1245af: a1 84 06 16 00 mov 0x160684,%eax <== NOT EXECUTED 1245b4: 85 c0 test %eax,%eax <== NOT EXECUTED 1245b6: 74 0c je 1245c4 <== NOT EXECUTED fclose(passwd_fp); 1245b8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1245bb: 50 push %eax <== NOT EXECUTED 1245bc: e8 6b c9 00 00 call 130f2c <== NOT EXECUTED 1245c1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED passwd_fp = fopen("/etc/passwd", "r"); 1245c4: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1245c7: 68 e1 19 14 00 push $0x1419e1 <== NOT EXECUTED 1245cc: 68 ad 40 14 00 push $0x1440ad <== NOT EXECUTED 1245d1: e8 c2 d0 00 00 call 131698 <== NOT EXECUTED 1245d6: a3 84 06 16 00 mov %eax,0x160684 <== NOT EXECUTED 1245db: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 1245de: c9 leave <== NOT EXECUTED 1245df: 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 ae 14 00 mov 0x14aeec,%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 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 00120f5c : #if !defined(RTEMS_POSIX_API) unsigned int sleep( unsigned int seconds ) { 120f5c: 55 push %ebp <== NOT EXECUTED 120f5d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 120f5f: 53 push %ebx <== NOT EXECUTED 120f60: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 120f63: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED rtems_status_code status; rtems_interval ticks_per_second; rtems_interval ticks; status = rtems_clock_get( 120f66: 8d 45 f8 lea -0x8(%ebp),%eax <== NOT EXECUTED 120f69: 50 push %eax <== NOT EXECUTED 120f6a: 6a 03 push $0x3 <== NOT EXECUTED 120f6c: e8 53 d6 fe ff call 10e5c4 <== NOT EXECUTED &ticks_per_second ); ticks = seconds * ticks_per_second; status = rtems_task_wake_after( ticks ); 120f71: 0f af 5d f8 imul -0x8(%ebp),%ebx <== NOT EXECUTED 120f75: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 120f78: e8 bf e5 fe ff call 10f53c <== NOT EXECUTED * Returns the "unslept" amount of time. In RTEMS signals are not * interruptable, so tasks really sleep all of the requested time. */ return 0; } 120f7d: 31 c0 xor %eax,%eax <== NOT EXECUTED 120f7f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 120f82: c9 leave <== NOT EXECUTED 120f83: 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 06 44 02 00 call 130de0 <__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 eb 43 02 00 call 130de0 <__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 001252a8 : int symlink( const char *actualpath, const char *sympath ) { 1252a8: 55 push %ebp <== NOT EXECUTED 1252a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1252ab: 57 push %edi <== NOT EXECUTED 1252ac: 56 push %esi <== NOT EXECUTED 1252ad: 53 push %ebx <== NOT EXECUTED 1252ae: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 1252b1: 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 ); 1252b4: 8a 03 mov (%ebx),%al <== NOT EXECUTED 1252b6: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 1252b8: 74 26 je 1252e0 <== NOT EXECUTED 1252ba: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 1252bc: 74 22 je 1252e0 <== NOT EXECUTED 1252be: 84 c0 test %al,%al <== NOT EXECUTED 1252c0: 74 1e je 1252e0 <== NOT EXECUTED 1252c2: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 1252c5: 89 45 c8 mov %eax,-0x38(%ebp) <== NOT EXECUTED 1252c8: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED 1252cd: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 1252d0: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1252d5: 8b 7d c8 mov -0x38(%ebp),%edi <== NOT EXECUTED 1252d8: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1252da: 31 d2 xor %edx,%edx <== NOT EXECUTED 1252dc: eb 1f jmp 1252fd <== NOT EXECUTED 1252de: 66 90 xchg %ax,%ax <== NOT EXECUTED 1252e0: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 1252e3: 89 45 c8 mov %eax,-0x38(%ebp) <== NOT EXECUTED 1252e6: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED 1252eb: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 1252ee: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 1252f3: 8b 7d c8 mov -0x38(%ebp),%edi <== NOT EXECUTED 1252f6: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1252f8: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start ); 1252fd: 51 push %ecx <== NOT EXECUTED 1252fe: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 125301: 50 push %eax <== NOT EXECUTED 125302: ff 75 c8 pushl -0x38(%ebp) <== NOT EXECUTED 125305: 8d 04 13 lea (%ebx,%edx,1),%eax <== NOT EXECUTED 125308: 50 push %eax <== NOT EXECUTED 125309: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 12530c: ff 50 04 call *0x4(%eax) <== NOT EXECUTED if ( result != 0 ) 12530f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125312: 85 c0 test %eax,%eax <== NOT EXECUTED 125314: 75 5e jne 125374 <== NOT EXECUTED return -1; if ( !loc.ops->symlink_h ) { 125316: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 125319: 8b 50 38 mov 0x38(%eax),%edx <== NOT EXECUTED 12531c: 85 d2 test %edx,%edx <== NOT EXECUTED 12531e: 74 34 je 125354 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*loc.ops->symlink_h)( &loc, actualpath, name_start); 125320: 50 push %eax <== NOT EXECUTED 125321: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 125324: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125327: ff 75 c8 pushl -0x38(%ebp) <== NOT EXECUTED 12532a: ff d2 call *%edx <== NOT EXECUTED 12532c: 89 c6 mov %eax,%esi <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 12532e: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 125331: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125334: 85 c0 test %eax,%eax <== NOT EXECUTED 125336: 74 12 je 12534a <== NOT EXECUTED 125338: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12533b: 85 c0 test %eax,%eax <== NOT EXECUTED 12533d: 74 0b je 12534a <== NOT EXECUTED 12533f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125342: ff 75 c8 pushl -0x38(%ebp) <== NOT EXECUTED 125345: ff d0 call *%eax <== NOT EXECUTED 125347: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 12534a: 89 f0 mov %esi,%eax <== NOT EXECUTED 12534c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12534f: 5b pop %ebx <== NOT EXECUTED 125350: 5e pop %esi <== NOT EXECUTED 125351: 5f pop %edi <== NOT EXECUTED 125352: c9 leave <== NOT EXECUTED 125353: 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 ); 125354: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 125357: 85 c0 test %eax,%eax <== NOT EXECUTED 125359: 74 0b je 125366 <== NOT EXECUTED 12535b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12535e: ff 75 c8 pushl -0x38(%ebp) <== NOT EXECUTED 125361: ff d0 call *%eax <== NOT EXECUTED 125363: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 125366: e8 75 ba 00 00 call 130de0 <__errno> <== NOT EXECUTED 12536b: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 125371: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 125374: 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; } 125379: 89 f0 mov %esi,%eax <== NOT EXECUTED 12537b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12537e: 5b pop %ebx <== NOT EXECUTED 12537f: 5e pop %esi <== NOT EXECUTED 125380: 5f pop %edi <== NOT EXECUTED 125381: c9 leave <== NOT EXECUTED 125382: c3 ret <== NOT EXECUTED 00125384 : #include int tcdrain( int fd ) { 125384: 55 push %ebp <== NOT EXECUTED 125385: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125387: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return ioctl( fd, RTEMS_IO_TCDRAIN, 0 ); 12538a: 6a 00 push $0x0 <== NOT EXECUTED 12538c: 6a 03 push $0x3 <== NOT EXECUTED 12538e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125391: e8 d6 f3 ff ff call 12476c <== NOT EXECUTED } 125396: c9 leave <== NOT EXECUTED 125397: c3 ret <== NOT EXECUTED 001156b8 : int tcgetattr( int fd, struct termios *tp ) { 1156b8: 55 push %ebp <== NOT EXECUTED 1156b9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1156bb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED return ioctl( fd, RTEMS_IO_GET_ATTRIBUTES, tp ); 1156be: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1156c1: 6a 01 push $0x1 <== NOT EXECUTED 1156c3: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 1156c6: e8 1d 2f 00 00 call 1185e8 <== NOT EXECUTED } 1156cb: c9 leave <== NOT EXECUTED 1156cc: c3 ret <== NOT EXECUTED 001156d0 : int tcsetattr( int fd, int opt, struct termios *tp ) { 1156d0: 55 push %ebp <== NOT EXECUTED 1156d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1156d3: 56 push %esi <== NOT EXECUTED 1156d4: 53 push %ebx <== NOT EXECUTED 1156d5: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 1156d8: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 1156db: 8b 5d 10 mov 0x10(%ebp),%ebx <== NOT EXECUTED switch (opt) { 1156de: 85 c0 test %eax,%eax <== NOT EXECUTED 1156e0: 74 2c je 11570e <== NOT EXECUTED 1156e2: 48 dec %eax <== NOT EXECUTED 1156e3: 74 17 je 1156fc <== NOT EXECUTED default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 1156e5: e8 2e 35 00 00 call 118c18 <__errno> <== NOT EXECUTED 1156ea: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); } } 1156f0: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1156f5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1156f8: 5b pop %ebx <== NOT EXECUTED 1156f9: 5e pop %esi <== NOT EXECUTED 1156fa: c9 leave <== NOT EXECUTED 1156fb: 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) 1156fc: 50 push %eax <== NOT EXECUTED 1156fd: 6a 00 push $0x0 <== NOT EXECUTED 1156ff: 6a 03 push $0x3 <== NOT EXECUTED 115701: 56 push %esi <== NOT EXECUTED 115702: e8 e1 2e 00 00 call 1185e8 <== NOT EXECUTED 115707: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11570a: 85 c0 test %eax,%eax <== NOT EXECUTED 11570c: 78 e2 js 1156f0 <== NOT EXECUTED return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 11570e: 89 5d 10 mov %ebx,0x10(%ebp) <== NOT EXECUTED 115711: c7 45 0c 02 00 00 00 movl $0x2,0xc(%ebp) <== NOT EXECUTED 115718: 89 75 08 mov %esi,0x8(%ebp) <== NOT EXECUTED } } 11571b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11571e: 5b pop %ebx <== NOT EXECUTED 11571f: 5e pop %esi <== NOT EXECUTED 115720: c9 leave <== NOT EXECUTED return -1; /* * Fall through to.... */ case TCSANOW: return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp ); 115721: e9 c2 2e 00 00 jmp 1185e8 <== 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 001254fc : */ char *ttyname( int fd ) { 1254fc: 55 push %ebp <== NOT EXECUTED 1254fd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1254ff: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED if ( !ttyname_r( fd, ttyname_buf, sizeof(ttyname_buf) ) ) 125502: 68 06 04 00 00 push $0x406 <== NOT EXECUTED 125507: 68 00 af 14 00 push $0x14af00 <== NOT EXECUTED 12550c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 12550f: e8 f4 fe ff ff call 125408 <== NOT EXECUTED 125514: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125517: 85 c0 test %eax,%eax <== NOT EXECUTED 125519: 75 09 jne 125524 <== NOT EXECUTED 12551b: b8 00 af 14 00 mov $0x14af00,%eax <== NOT EXECUTED return ttyname_buf; return NULL; } 125520: c9 leave <== NOT EXECUTED 125521: c3 ret <== NOT EXECUTED 125522: 66 90 xchg %ax,%ax <== NOT EXECUTED char *ttyname( int fd ) { if ( !ttyname_r( fd, ttyname_buf, sizeof(ttyname_buf) ) ) 125524: 31 c0 xor %eax,%eax <== NOT EXECUTED return ttyname_buf; return NULL; } 125526: c9 leave <== NOT EXECUTED 125527: c3 ret <== NOT EXECUTED 00125408 : int ttyname_r( int fd, char *name, size_t namesize ) { 125408: 55 push %ebp <== NOT EXECUTED 125409: 89 e5 mov %esp,%ebp <== NOT EXECUTED 12540b: 57 push %edi <== NOT EXECUTED 12540c: 56 push %esi <== NOT EXECUTED 12540d: 53 push %ebx <== NOT EXECUTED 12540e: 81 ec d4 00 00 00 sub $0xd4,%esp <== NOT EXECUTED 125414: 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) 125417: 8d 45 d0 lea -0x30(%ebp),%eax <== NOT EXECUTED 12541a: 50 push %eax <== NOT EXECUTED 12541b: 53 push %ebx <== NOT EXECUTED 12541c: e8 77 ff ff ff call 125398 <== NOT EXECUTED 125421: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125424: 85 c0 test %eax,%eax <== NOT EXECUTED 125426: 78 23 js 12544b <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EBADF); /* Must be a character device. */ if (fstat (fd, &sb) || !S_ISCHR (sb.st_mode)) 125428: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 12542b: 8d 45 84 lea -0x7c(%ebp),%eax <== NOT EXECUTED 12542e: 50 push %eax <== NOT EXECUTED 12542f: 53 push %ebx <== NOT EXECUTED 125430: e8 db e3 ff ff call 123810 <== NOT EXECUTED 125435: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125438: 85 c0 test %eax,%eax <== NOT EXECUTED 12543a: 75 0f jne 12544b <== NOT EXECUTED 12543c: 8b 45 90 mov -0x70(%ebp),%eax <== NOT EXECUTED 12543f: 25 00 f0 00 00 and $0xf000,%eax <== NOT EXECUTED 125444: 3d 00 20 00 00 cmp $0x2000,%eax <== NOT EXECUTED 125449: 74 19 je 125464 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(EBADF); if ((dp = opendir (_PATH_DEV)) == NULL) rtems_set_errno_and_return_minus_one(EBADF); 12544b: e8 90 b9 00 00 call 130de0 <__errno> <== NOT EXECUTED 125450: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 125456: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED rval = name; break; } (void) closedir (dp); return 0; } 12545b: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 12545e: 5b pop %ebx <== NOT EXECUTED 12545f: 5e pop %esi <== NOT EXECUTED 125460: 5f pop %edi <== NOT EXECUTED 125461: c9 leave <== NOT EXECUTED 125462: c3 ret <== NOT EXECUTED 125463: 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) 125464: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125467: 68 ff 41 14 00 push $0x1441ff <== NOT EXECUTED 12546c: e8 cb f8 ff ff call 124d3c <== NOT EXECUTED 125471: 89 c3 mov %eax,%ebx <== NOT EXECUTED 125473: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125476: 85 c0 test %eax,%eax <== NOT EXECUTED 125478: 74 d1 je 12544b <== 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); 12547a: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 12547d: 83 c6 05 add $0x5,%esi <== NOT EXECUTED if (stat (name, &dsb) || sb.st_dev != dsb.st_dev || 125480: 8d bd 38 ff ff ff lea -0xc8(%ebp),%edi <== NOT EXECUTED 125486: 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 ;) 125488: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12548b: 53 push %ebx <== NOT EXECUTED 12548c: e8 53 fb ff ff call 124fe4 <== NOT EXECUTED 125491: 89 c2 mov %eax,%edx <== NOT EXECUTED 125493: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125496: 85 c0 test %eax,%eax <== NOT EXECUTED 125498: 74 4a je 1254e4 <== NOT EXECUTED { if (dirp->d_ino != sb.st_ino) 12549a: 8b 02 mov (%edx),%eax <== NOT EXECUTED 12549c: 3b 45 8c cmp -0x74(%ebp),%eax <== NOT EXECUTED 12549f: 75 e7 jne 125488 <== NOT EXECUTED continue; strcpy (name + sizeof (_PATH_DEV) - 1, dirp->d_name); 1254a1: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1254a4: 8d 42 0c lea 0xc(%edx),%eax <== NOT EXECUTED 1254a7: 50 push %eax <== NOT EXECUTED 1254a8: 56 push %esi <== NOT EXECUTED 1254a9: e8 e6 fd 00 00 call 135294 <== NOT EXECUTED if (stat (name, &dsb) || sb.st_dev != dsb.st_dev || 1254ae: 58 pop %eax <== NOT EXECUTED 1254af: 5a pop %edx <== NOT EXECUTED 1254b0: 57 push %edi <== NOT EXECUTED 1254b1: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1254b4: e8 97 74 fe ff call 10c950 <== NOT EXECUTED 1254b9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1254bc: 85 c0 test %eax,%eax <== NOT EXECUTED 1254be: 75 c8 jne 125488 <== NOT EXECUTED 1254c0: 8b 55 84 mov -0x7c(%ebp),%edx <== NOT EXECUTED 1254c3: 8b 45 88 mov -0x78(%ebp),%eax <== NOT EXECUTED 1254c6: 33 85 3c ff ff ff xor -0xc4(%ebp),%eax <== NOT EXECUTED 1254cc: 33 95 38 ff ff ff xor -0xc8(%ebp),%edx <== NOT EXECUTED 1254d2: 09 d0 or %edx,%eax <== NOT EXECUTED 1254d4: 75 b2 jne 125488 <== NOT EXECUTED 1254d6: 8b 45 8c mov -0x74(%ebp),%eax <== NOT EXECUTED 1254d9: 3b 85 40 ff ff ff cmp -0xc0(%ebp),%eax <== NOT EXECUTED 1254df: 75 a7 jne 125488 <== NOT EXECUTED 1254e1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED sb.st_ino != dsb.st_ino) continue; rval = name; break; } (void) closedir (dp); 1254e4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1254e7: 53 push %ebx <== NOT EXECUTED 1254e8: e8 cb 9b 00 00 call 12f0b8 <== NOT EXECUTED 1254ed: 31 c0 xor %eax,%eax <== NOT EXECUTED 1254ef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 1254f2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1254f5: 5b pop %ebx <== NOT EXECUTED 1254f6: 5e pop %esi <== NOT EXECUTED 1254f7: 5f pop %edi <== NOT EXECUTED 1254f8: c9 leave <== NOT EXECUTED 1254f9: c3 ret <== NOT EXECUTED 00125528 : #include mode_t umask( mode_t cmask ) { 125528: 55 push %ebp <== NOT EXECUTED 125529: 89 e5 mov %esp,%ebp <== NOT EXECUTED mode_t old_mask; old_mask = rtems_filesystem_umask; 12552b: 8b 15 ec ae 14 00 mov 0x14aeec,%edx <== NOT EXECUTED 125531: 8b 42 24 mov 0x24(%edx),%eax <== NOT EXECUTED rtems_filesystem_umask = cmask; 125534: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 125537: 89 4a 24 mov %ecx,0x24(%edx) <== NOT EXECUTED return old_mask; } 12553a: c9 leave <== NOT EXECUTED 12553b: c3 ret <== 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 5f 26 02 00 call 130de0 <__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 17 26 02 00 call 130de0 <__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 eb 25 02 00 call 130de0 <__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 00125584 : */ int unmount( const char *path ) { 125584: 55 push %ebp <== NOT EXECUTED 125585: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125587: 56 push %esi <== NOT EXECUTED 125588: 53 push %ebx <== NOT EXECUTED 125589: 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 ) ) 12558c: 6a 01 push $0x1 <== NOT EXECUTED 12558e: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 125591: 56 push %esi <== NOT EXECUTED 125592: 6a 00 push $0x0 <== NOT EXECUTED 125594: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125597: e8 90 5c fe ff call 10b22c <== NOT EXECUTED 12559c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12559f: 85 c0 test %eax,%eax <== NOT EXECUTED 1255a1: 0f 85 90 00 00 00 jne 125637 <== NOT EXECUTED return -1; mt_entry = loc.mt_entry; 1255a7: 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) ){ 1255aa: 8b 43 18 mov 0x18(%ebx),%eax <== NOT EXECUTED 1255ad: 3b 45 e8 cmp -0x18(%ebp),%eax <== NOT EXECUTED 1255b0: 0f 85 a6 00 00 00 jne 12565c <== NOT EXECUTED /* * Free the loc node and just use the nodes from the mt_entry . */ rtems_filesystem_freenode( &loc ); 1255b6: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1255b9: 85 c0 test %eax,%eax <== NOT EXECUTED 1255bb: 74 10 je 1255cd <== NOT EXECUTED 1255bd: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1255c0: 85 c0 test %eax,%eax <== NOT EXECUTED 1255c2: 74 09 je 1255cd <== NOT EXECUTED 1255c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1255c7: 56 push %esi <== NOT EXECUTED 1255c8: ff d0 call *%eax <== NOT EXECUTED 1255ca: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Verify Unmount is supported by both filesystems. */ if ( !fs_mount_loc->ops->unmount_h ) 1255cd: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 1255d0: 8b 50 28 mov 0x28(%eax),%edx <== NOT EXECUTED 1255d3: 85 d2 test %edx,%edx <== NOT EXECUTED 1255d5: 0f 84 1d 01 00 00 je 1256f8 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( !fs_root_loc->ops->fsunmount_me_h ) 1255db: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 1255de: 8b 40 2c mov 0x2c(%eax),%eax <== NOT EXECUTED 1255e1: 85 c0 test %eax,%eax <== NOT EXECUTED 1255e3: 0f 84 0f 01 00 00 je 1256f8 <== 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 ) 1255e9: a1 ec ae 14 00 mov 0x14aeec,%eax <== NOT EXECUTED 1255ee: 39 58 10 cmp %ebx,0x10(%eax) <== NOT EXECUTED 1255f1: 74 51 je 125644 <== NOT EXECUTED /* * Search the mount table for any mount entries referencing this * mount entry. */ for ( the_node = rtems_filesystem_mount_table_control.first; 1255f3: a1 2c 11 16 00 mov 0x16112c,%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 1255f8: b9 30 11 16 00 mov $0x161130,%ecx <== NOT EXECUTED !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); 1255fd: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 1255ff: 74 16 je 125617 <== 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 ) { 125601: 8b 53 24 mov 0x24(%ebx),%edx <== NOT EXECUTED 125604: 39 50 14 cmp %edx,0x14(%eax) <== NOT EXECUTED 125607: 75 08 jne 125611 <== NOT EXECUTED 125609: eb 39 jmp 125644 <== NOT EXECUTED 12560b: 90 nop <== NOT EXECUTED 12560c: 3b 50 14 cmp 0x14(%eax),%edx <== NOT EXECUTED 12560f: 74 33 je 125644 <== 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 ) { 125611: 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 ); 125613: 39 c1 cmp %eax,%ecx <== NOT EXECUTED 125615: 75 f5 jne 12560c <== 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 ) 125617: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12561a: 53 push %ebx <== NOT EXECUTED 12561b: e8 a8 5f fe ff call 10b5c8 <== NOT EXECUTED 125620: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125623: 48 dec %eax <== NOT EXECUTED 125624: 74 1e je 125644 <== 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 ) 125626: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125629: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 12562c: 53 push %ebx <== NOT EXECUTED 12562d: ff 50 28 call *0x28(%eax) <== NOT EXECUTED 125630: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125633: 85 c0 test %eax,%eax <== NOT EXECUTED 125635: 74 55 je 12568c <== NOT EXECUTED */ rtems_filesystem_freenode( fs_mount_loc ); free( mt_entry ); return 0; 125637: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED } 12563c: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 12563f: 5b pop %ebx <== NOT EXECUTED 125640: 5e pop %esi <== NOT EXECUTED 125641: c9 leave <== NOT EXECUTED 125642: c3 ret <== NOT EXECUTED 125643: 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 ); 125644: e8 97 b7 00 00 call 130de0 <__errno> <== NOT EXECUTED 125649: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED 12564f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED rtems_filesystem_freenode( fs_mount_loc ); free( mt_entry ); return 0; } 125654: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 125657: 5b pop %ebx <== NOT EXECUTED 125658: 5e pop %esi <== NOT EXECUTED 125659: c9 leave <== NOT EXECUTED 12565a: c3 ret <== NOT EXECUTED 12565b: 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 ); 12565c: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 12565f: 85 c0 test %eax,%eax <== NOT EXECUTED 125661: 74 10 je 125673 <== NOT EXECUTED 125663: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 125666: 85 c0 test %eax,%eax <== NOT EXECUTED 125668: 74 09 je 125673 <== NOT EXECUTED 12566a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12566d: 56 push %esi <== NOT EXECUTED 12566e: ff d0 call *%eax <== NOT EXECUTED 125670: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); 125673: e8 68 b7 00 00 call 130de0 <__errno> <== NOT EXECUTED 125678: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 12567e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED rtems_filesystem_freenode( fs_mount_loc ); free( mt_entry ); return 0; } 125683: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 125686: 5b pop %ebx <== NOT EXECUTED 125687: 5e pop %esi <== NOT EXECUTED 125688: c9 leave <== NOT EXECUTED 125689: c3 ret <== NOT EXECUTED 12568a: 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){ 12568c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12568f: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 125692: 53 push %ebx <== NOT EXECUTED 125693: ff 50 2c call *0x2c(%eax) <== NOT EXECUTED 125696: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 125699: 85 c0 test %eax,%eax <== NOT EXECUTED 12569b: 75 39 jne 1256d6 <== NOT EXECUTED 12569d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1256a0: 53 push %ebx <== NOT EXECUTED 1256a1: e8 56 a6 fe ff call 10fcfc <_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 ); 1256a6: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 1256a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1256ac: 85 c0 test %eax,%eax <== NOT EXECUTED 1256ae: 74 13 je 1256c3 <== NOT EXECUTED 1256b0: 8b 50 1c mov 0x1c(%eax),%edx <== NOT EXECUTED 1256b3: 85 d2 test %edx,%edx <== NOT EXECUTED 1256b5: 74 0c je 1256c3 <== NOT EXECUTED 1256b7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1256ba: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 1256bd: 50 push %eax <== NOT EXECUTED 1256be: ff d2 call *%edx <== NOT EXECUTED 1256c0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED free( mt_entry ); 1256c3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1256c6: 53 push %ebx <== NOT EXECUTED 1256c7: e8 a4 5c fe ff call 10b370 <== NOT EXECUTED 1256cc: 31 c0 xor %eax,%eax <== NOT EXECUTED 1256ce: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1256d1: e9 66 ff ff ff jmp 12563c <== 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 ) 1256d6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1256d9: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 1256dc: 53 push %ebx <== NOT EXECUTED 1256dd: ff 50 20 call *0x20(%eax) <== NOT EXECUTED 1256e0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1256e3: 85 c0 test %eax,%eax <== NOT EXECUTED 1256e5: 0f 84 4c ff ff ff je 125637 <== NOT EXECUTED rtems_fatal_error_occurred( 0 ); 1256eb: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1256ee: 6a 00 push $0x0 <== NOT EXECUTED 1256f0: e8 eb a2 fe ff call 10f9e0 <== NOT EXECUTED 1256f5: 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 ); 1256f8: e8 e3 b6 00 00 call 130de0 <__errno> <== NOT EXECUTED 1256fd: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 125703: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 125708: e9 2f ff ff ff jmp 12563c <== NOT EXECUTED 00125710 : int utime( const char *path, const struct utimbuf *times ) { 125710: 55 push %ebp <== NOT EXECUTED 125711: 89 e5 mov %esp,%ebp <== NOT EXECUTED 125713: 56 push %esi <== NOT EXECUTED 125714: 53 push %ebx <== NOT EXECUTED 125715: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 125718: 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 ) ) 12571b: 6a 01 push $0x1 <== NOT EXECUTED 12571d: 8d 75 e8 lea -0x18(%ebp),%esi <== NOT EXECUTED 125720: 56 push %esi <== NOT EXECUTED 125721: 6a 00 push $0x0 <== NOT EXECUTED 125723: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 125726: e8 01 5b fe ff call 10b22c <== NOT EXECUTED 12572b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12572e: 85 c0 test %eax,%eax <== NOT EXECUTED 125730: 75 56 jne 125788 <== NOT EXECUTED return -1; if ( !temp_loc.ops->utime_h ){ 125732: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 125735: 8b 50 30 mov 0x30(%eax),%edx <== NOT EXECUTED 125738: 85 d2 test %edx,%edx <== NOT EXECUTED 12573a: 74 2e je 12576a <== 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 ); 12573c: 50 push %eax <== NOT EXECUTED 12573d: ff 73 04 pushl 0x4(%ebx) <== NOT EXECUTED 125740: ff 33 pushl (%ebx) <== NOT EXECUTED 125742: 56 push %esi <== NOT EXECUTED 125743: ff d2 call *%edx <== NOT EXECUTED 125745: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_filesystem_freenode( &temp_loc ); 125747: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 12574a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 12574d: 85 c0 test %eax,%eax <== NOT EXECUTED 12574f: 74 10 je 125761 <== NOT EXECUTED 125751: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 125754: 85 c0 test %eax,%eax <== NOT EXECUTED 125756: 74 09 je 125761 <== NOT EXECUTED 125758: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 12575b: 56 push %esi <== NOT EXECUTED 12575c: ff d0 call *%eax <== NOT EXECUTED 12575e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 125761: 89 d8 mov %ebx,%eax <== NOT EXECUTED 125763: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 125766: 5b pop %ebx <== NOT EXECUTED 125767: 5e pop %esi <== NOT EXECUTED 125768: c9 leave <== NOT EXECUTED 125769: 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 ); 12576a: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 12576d: 85 c0 test %eax,%eax <== NOT EXECUTED 12576f: 74 09 je 12577a <== NOT EXECUTED 125771: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 125774: 56 push %esi <== NOT EXECUTED 125775: ff d0 call *%eax <== NOT EXECUTED 125777: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 12577a: e8 61 b6 00 00 call 130de0 <__errno> <== NOT EXECUTED 12577f: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 125785: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 125788: 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; } 12578d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 12578f: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 125792: 5b pop %ebx <== NOT EXECUTED 125793: 5e pop %esi <== NOT EXECUTED 125794: c9 leave <== NOT EXECUTED 125795: 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 44 a5 11 00 call *0x11a544 <== 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 44 a5 11 00 call *0x11a544 <== 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 24 84 11 00 jmp *0x118424(,%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 44 a5 11 00 call *0x11a544 <== 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 12 84 11 00 movsbl 0x118412(%eax),%eax <== NOT EXECUTED 107c4f: 50 push %eax <== NOT EXECUTED 107c50: ff 15 44 a5 11 00 call *0x11a544 <== 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 44 a5 11 00 call *0x11a544 <== 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 44 a5 11 00 call *0x11a544 <== 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 44 a5 11 00 call *0x11a544 <== 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 44 a5 11 00 call *0x11a544 <== 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 44 a5 11 00 call *0x11a544 <== 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 00116934 : ssize_t write( int fd, const void *buffer, size_t count ) { 116934: 55 push %ebp <== NOT EXECUTED 116935: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116937: 56 push %esi <== NOT EXECUTED 116938: 53 push %ebx <== NOT EXECUTED 116939: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 11693c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11693f: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 116942: 3b 15 e0 a3 11 00 cmp 0x11a3e0,%edx <== NOT EXECUTED 116948: 73 56 jae 1169a0 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 11694a: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 11694d: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 116950: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 116957: 03 1d 70 e8 11 00 add 0x11e870,%ebx <== NOT EXECUTED rtems_libio_check_is_open( iop ); 11695d: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 116960: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 116963: 74 3b je 1169a0 <== NOT EXECUTED rtems_libio_check_buffer( buffer ); 116965: 85 f6 test %esi,%esi <== NOT EXECUTED 116967: 74 4b je 1169b4 <== NOT EXECUTED rtems_libio_check_count( count ); 116969: 85 c9 test %ecx,%ecx <== NOT EXECUTED 11696b: 74 27 je 116994 <== NOT EXECUTED rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 11696d: a8 04 test $0x4,%al <== NOT EXECUTED 11696f: 74 43 je 1169b4 <== NOT EXECUTED /* * Now process the write() request. */ if ( !iop->handlers->write_h ) 116971: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 116974: 8b 40 0c mov 0xc(%eax),%eax <== NOT EXECUTED 116977: 85 c0 test %eax,%eax <== NOT EXECUTED 116979: 74 4b je 1169c6 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); rc = (*iop->handlers->write_h)( iop, buffer, count ); 11697b: 52 push %edx <== NOT EXECUTED 11697c: 51 push %ecx <== NOT EXECUTED 11697d: 56 push %esi <== NOT EXECUTED 11697e: 53 push %ebx <== NOT EXECUTED 11697f: ff d0 call *%eax <== NOT EXECUTED if ( rc > 0 ) 116981: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116984: 85 c0 test %eax,%eax <== NOT EXECUTED 116986: 7e 03 jle 11698b <== NOT EXECUTED iop->offset += rc; 116988: 01 43 08 add %eax,0x8(%ebx) <== NOT EXECUTED return rc; } 11698b: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11698e: 5b pop %ebx <== NOT EXECUTED 11698f: 5e pop %esi <== NOT EXECUTED 116990: c9 leave <== NOT EXECUTED 116991: c3 ret <== NOT EXECUTED 116992: 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 ); 116994: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( rc > 0 ) iop->offset += rc; return rc; } 116996: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 116999: 5b pop %ebx <== NOT EXECUTED 11699a: 5e pop %esi <== NOT EXECUTED 11699b: c9 leave <== NOT EXECUTED 11699c: c3 ret <== NOT EXECUTED 11699d: 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 ); 1169a0: e8 13 98 ff ff call 1101b8 <__errno> <== NOT EXECUTED 1169a5: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 1169ab: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1169b0: eb d9 jmp 11698b <== NOT EXECUTED 1169b2: 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 ); 1169b4: e8 ff 97 ff ff call 1101b8 <__errno> <== NOT EXECUTED 1169b9: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1169bf: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1169c4: eb c5 jmp 11698b <== NOT EXECUTED /* * Now process the write() request. */ if ( !iop->handlers->write_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 1169c6: e8 ed 97 ff ff call 1101b8 <__errno> <== NOT EXECUTED 1169cb: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1169d1: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1169d6: eb b3 jmp 11698b <== NOT EXECUTED