=============================================================================== 0010d840 : #define MAXSYMLINK 5 int IMFS_Set_handlers( rtems_filesystem_location_info_t *loc ) { 10d840: 55 push %ebp 10d841: 89 e5 mov %esp,%ebp 10d843: 8b 55 08 mov 0x8(%ebp),%edx IMFS_jnode_t *node = loc->node_access; IMFS_fs_info_t *fs_info; fs_info = loc->mt_entry->fs_info; 10d846: 8b 42 0c mov 0xc(%edx),%eax 10d849: 8b 48 2c mov 0x2c(%eax),%ecx switch( node->type ) { 10d84c: 8b 02 mov (%edx),%eax 10d84e: 83 78 4c 06 cmpl $0x6,0x4c(%eax) 10d852: 77 12 ja 10d866 <== NEVER TAKEN 10d854: 8b 40 4c mov 0x4c(%eax),%eax 10d857: ff 24 85 40 89 11 00 jmp *0x118940(,%eax,4) 10d85e: 66 90 xchg %ax,%ax case IMFS_DIRECTORY: loc->handlers = fs_info->directory_handlers; 10d860: 8b 41 08 mov 0x8(%ecx),%eax 10d863: 89 42 04 mov %eax,0x4(%edx) loc->handlers = fs_info->memfile_handlers; break; } return 0; } 10d866: 31 c0 xor %eax,%eax 10d868: c9 leave 10d869: c3 ret 10d86a: 66 90 xchg %ax,%ax break; case IMFS_LINEAR_FILE: loc->handlers = fs_info->memfile_handlers; break; case IMFS_MEMORY_FILE: loc->handlers = fs_info->memfile_handlers; 10d86c: 8b 41 04 mov 0x4(%ecx),%eax <== NOT EXECUTED 10d86f: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED break; } return 0; } 10d872: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d874: c9 leave <== NOT EXECUTED 10d875: c3 ret <== NOT EXECUTED 10d876: 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; 10d878: c7 42 04 80 8a 11 00 movl $0x118a80,0x4(%edx) <== NOT EXECUTED loc->handlers = fs_info->memfile_handlers; break; } return 0; } 10d87f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d881: c9 leave <== NOT EXECUTED 10d882: c3 ret <== NOT EXECUTED 10d883: 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; 10d884: c7 42 04 40 8a 11 00 movl $0x118a40,0x4(%edx) loc->handlers = fs_info->memfile_handlers; break; } return 0; } 10d88b: 31 c0 xor %eax,%eax 10d88d: c9 leave 10d88e: c3 ret =============================================================================== 0010fac4 : IMFS_jnode_types_t type, const char *name, mode_t mode, const IMFS_types_union *info ) { 10fac4: 55 push %ebp 10fac5: 89 e5 mov %esp,%ebp 10fac7: 57 push %edi 10fac8: 56 push %esi 10fac9: 53 push %ebx 10faca: 83 ec 1c sub $0x1c,%esp 10facd: 8b 75 14 mov 0x14(%ebp),%esi IMFS_jnode_t *node; struct timeval tv; IMFS_jnode_t *parent = NULL; IMFS_fs_info_t *fs_info; if ( parent_loc != NULL ) 10fad0: 8b 5d 08 mov 0x8(%ebp),%ebx 10fad3: 85 db test %ebx,%ebx 10fad5: 0f 84 29 01 00 00 je 10fc04 parent = parent_loc->node_access; 10fadb: 8b 45 08 mov 0x8(%ebp),%eax 10fade: 8b 38 mov (%eax),%edi /* * Allocate an IMFS jnode */ node = calloc( 1, sizeof( IMFS_jnode_t ) ); 10fae0: 83 ec 08 sub $0x8,%esp 10fae3: 6a 60 push $0x60 10fae5: 6a 01 push $0x1 10fae7: e8 d0 e9 ff ff call 10e4bc 10faec: 89 c3 mov %eax,%ebx if ( !node ) 10faee: 83 c4 10 add $0x10,%esp 10faf1: 85 c0 test %eax,%eax 10faf3: 0f 84 9f 00 00 00 je 10fb98 <== NEVER TAKEN /* * Fill in the basic information */ node->st_nlink = 1; 10faf9: 66 c7 40 34 01 00 movw $0x1,0x34(%eax) node->type = type; 10faff: 8b 55 0c mov 0xc(%ebp),%edx 10fb02: 89 50 4c mov %edx,0x4c(%eax) strncpy( node->name, name, IMFS_NAME_MAX ); 10fb05: 51 push %ecx 10fb06: 6a 20 push $0x20 10fb08: ff 75 10 pushl 0x10(%ebp) 10fb0b: 8d 40 0c lea 0xc(%eax),%eax 10fb0e: 50 push %eax 10fb0f: e8 94 18 00 00 call 1113a8 /* * Fill in the mode and permission information for the jnode structure. */ node->st_mode = mode & ~rtems_filesystem_umask; 10fb14: a1 b4 c4 11 00 mov 0x11c4b4,%eax 10fb19: 8b 40 24 mov 0x24(%eax),%eax 10fb1c: f7 d0 not %eax 10fb1e: 21 c6 and %eax,%esi 10fb20: 89 73 30 mov %esi,0x30(%ebx) #if defined(RTEMS_POSIX_API) node->st_uid = geteuid(); node->st_gid = getegid(); #else node->st_uid = 0; 10fb23: 66 c7 43 3c 00 00 movw $0x0,0x3c(%ebx) node->st_gid = 0; 10fb29: 66 c7 43 3e 00 00 movw $0x0,0x3e(%ebx) /* * Now set all the times. */ gettimeofday( &tv, 0 ); 10fb2f: 58 pop %eax 10fb30: 5a pop %edx 10fb31: 6a 00 push $0x0 10fb33: 8d 45 ec lea -0x14(%ebp),%eax 10fb36: 50 push %eax 10fb37: e8 18 eb ff ff call 10e654 node->stat_atime = (time_t) tv.tv_sec; 10fb3c: 8b 45 ec mov -0x14(%ebp),%eax 10fb3f: 89 43 40 mov %eax,0x40(%ebx) node->stat_mtime = (time_t) tv.tv_sec; 10fb42: 89 43 44 mov %eax,0x44(%ebx) node->stat_ctime = (time_t) tv.tv_sec; 10fb45: 89 43 48 mov %eax,0x48(%ebx) /* * Set the type specific information */ switch (type) { 10fb48: 83 c4 10 add $0x10,%esp 10fb4b: 83 7d 0c 06 cmpl $0x6,0xc(%ebp) 10fb4f: 76 53 jbe 10fba4 <== ALWAYS TAKEN node->info.file.doubly_indirect = 0; node->info.file.triply_indirect = 0; break; default: assert(0); 10fb51: 68 c8 82 11 00 push $0x1182c8 <== NOT EXECUTED 10fb56: 68 1c 8d 11 00 push $0x118d1c <== NOT EXECUTED 10fb5b: 6a 74 push $0x74 <== NOT EXECUTED 10fb5d: 68 b0 8c 11 00 push $0x118cb0 <== NOT EXECUTED 10fb62: e8 21 73 ff ff call 106e88 <__assert_func> <== NOT EXECUTED 10fb67: 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; 10fb68: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 10fb6b: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10fb6d: 89 43 50 mov %eax,0x50(%ebx) <== NOT EXECUTED /* * If this node has a parent, then put it in that directory list. */ if ( parent ) { 10fb70: 85 ff test %edi,%edi 10fb72: 74 24 je 10fb98 10fb74: 83 ec 08 sub $0x8,%esp 10fb77: 53 push %ebx 10fb78: 8d 47 50 lea 0x50(%edi),%eax 10fb7b: 50 push %eax 10fb7c: e8 fb b1 ff ff call 10ad7c <_Chain_Append> rtems_chain_append( &parent->info.directory.Entries, &node->Node ); node->Parent = parent; 10fb81: 89 7b 08 mov %edi,0x8(%ebx) fs_info = parent_loc->mt_entry->fs_info; 10fb84: 8b 55 08 mov 0x8(%ebp),%edx 10fb87: 8b 42 0c mov 0xc(%edx),%eax 10fb8a: 8b 50 2c mov 0x2c(%eax),%edx node->st_ino = ++fs_info->ino_count; 10fb8d: 8b 02 mov (%edx),%eax 10fb8f: 40 inc %eax 10fb90: 89 02 mov %eax,(%edx) 10fb92: 89 43 38 mov %eax,0x38(%ebx) 10fb95: 83 c4 10 add $0x10,%esp } return node; } 10fb98: 89 d8 mov %ebx,%eax 10fb9a: 8d 65 f4 lea -0xc(%ebp),%esp 10fb9d: 5b pop %ebx 10fb9e: 5e pop %esi 10fb9f: 5f pop %edi 10fba0: c9 leave 10fba1: c3 ret 10fba2: 66 90 xchg %ax,%ax /* * Set the type specific information */ switch (type) { 10fba4: 8b 45 0c mov 0xc(%ebp),%eax 10fba7: ff 24 85 00 8d 11 00 jmp *0x118d00(,%eax,4) 10fbae: 66 90 xchg %ax,%ax node->info.device.major = info->device.major; node->info.device.minor = info->device.minor; break; case IMFS_LINEAR_FILE: node->info.linearfile.size = 0; 10fbb0: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED node->info.linearfile.direct = 0; 10fbb7: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED case IMFS_MEMORY_FILE: node->info.file.size = 0; 10fbbe: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) <== NOT EXECUTED node->info.file.indirect = 0; 10fbc5: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) <== NOT EXECUTED node->info.file.doubly_indirect = 0; 10fbcc: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx) <== NOT EXECUTED node->info.file.triply_indirect = 0; 10fbd3: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) <== NOT EXECUTED 10fbda: eb 94 jmp 10fb70 <== 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; 10fbdc: 8b 55 18 mov 0x18(%ebp),%edx 10fbdf: 8b 02 mov (%edx),%eax 10fbe1: 89 43 50 mov %eax,0x50(%ebx) node->info.device.minor = info->device.minor; 10fbe4: 8b 42 04 mov 0x4(%edx),%eax 10fbe7: 89 43 54 mov %eax,0x54(%ebx) 10fbea: eb 84 jmp 10fb70 10fbec: 8d 43 54 lea 0x54(%ebx),%eax 10fbef: 89 43 50 mov %eax,0x50(%ebx) 10fbf2: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) 10fbf9: 8d 43 50 lea 0x50(%ebx),%eax 10fbfc: 89 43 58 mov %eax,0x58(%ebx) 10fbff: e9 6c ff ff ff jmp 10fb70 IMFS_jnode_t *node; struct timeval tv; IMFS_jnode_t *parent = NULL; IMFS_fs_info_t *fs_info; if ( parent_loc != NULL ) 10fc04: 31 ff xor %edi,%edi 10fc06: e9 d5 fe ff ff jmp 10fae0 =============================================================================== 0010d9e0 : int IMFS_eval_path( const char *pathname, /* IN */ int flags, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10d9e0: 55 push %ebp 10d9e1: 89 e5 mov %esp,%ebp 10d9e3: 57 push %edi 10d9e4: 56 push %esi 10d9e5: 53 push %ebx 10d9e6: 83 ec 5c sub $0x5c,%esp char token[ IMFS_NAME_MAX + 1 ]; rtems_filesystem_location_info_t newloc; IMFS_jnode_t *node; int result; if ( !rtems_libio_is_valid_perms( flags ) ) { 10d9e9: f7 45 0c f8 ff ff ff testl $0xfffffff8,0xc(%ebp) 10d9f0: 0f 85 0a 02 00 00 jne 10dc00 <== NEVER TAKEN /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10d9f6: 8b 45 10 mov 0x10(%ebp),%eax 10d9f9: 8b 30 mov (%eax),%esi 10d9fb: c7 45 a4 00 00 00 00 movl $0x0,-0x5c(%ebp) * 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 ); 10da02: 50 push %eax 10da03: 8d 55 f0 lea -0x10(%ebp),%edx 10da06: 52 push %edx 10da07: 8d 4d bf lea -0x41(%ebp),%ecx 10da0a: 51 push %ecx 10da0b: 8b 45 08 mov 0x8(%ebp),%eax 10da0e: 03 45 a4 add -0x5c(%ebp),%eax 10da11: 50 push %eax 10da12: e8 15 06 00 00 call 10e02c 10da17: 89 c3 mov %eax,%ebx i += len; 10da19: 8b 45 f0 mov -0x10(%ebp),%eax if ( !pathloc->node_access ) 10da1c: 8b 7d 10 mov 0x10(%ebp),%edi 10da1f: 8b 17 mov (%edi),%edx 10da21: 83 c4 10 add $0x10,%esp 10da24: 85 d2 test %edx,%edx 10da26: 0f 84 94 01 00 00 je 10dbc0 <== NEVER TAKEN */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { type = IMFS_get_token( &pathname[i], token, &len ); i += len; 10da2c: 01 45 a4 add %eax,-0x5c(%ebp) rtems_set_errno_and_return_minus_one( ENOENT ); /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10da2f: 85 db test %ebx,%ebx 10da31: 75 51 jne 10da84 * 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 ) { 10da33: 83 7a 4c 01 cmpl $0x1,0x4c(%edx) 10da37: 0f 85 2f 01 00 00 jne 10db6c if ( node->info.directory.mt_fs != NULL ) { 10da3d: 8b 52 5c mov 0x5c(%edx),%edx 10da40: 85 d2 test %edx,%edx 10da42: 0f 84 24 01 00 00 je 10db6c <== ALWAYS TAKEN newloc = node->info.directory.mt_fs->mt_fs_root; 10da48: 8d 45 e0 lea -0x20(%ebp),%eax <== NOT EXECUTED 10da4b: 8d 72 18 lea 0x18(%edx),%esi <== NOT EXECUTED 10da4e: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10da53: 89 c7 mov %eax,%edi <== NOT EXECUTED 10da55: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10da57: 89 c6 mov %eax,%esi <== NOT EXECUTED 10da59: b1 04 mov $0x4,%cl <== NOT EXECUTED 10da5b: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10da5e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc ); 10da60: 57 push %edi <== NOT EXECUTED 10da61: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10da64: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10da67: 50 push %eax <== NOT EXECUTED 10da68: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10da6b: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10da6e: 29 4d a4 sub %ecx,-0x5c(%ebp) <== NOT EXECUTED 10da71: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10da74: 03 45 a4 add -0x5c(%ebp),%eax <== NOT EXECUTED 10da77: 50 push %eax <== NOT EXECUTED 10da78: ff 12 call *(%edx) <== NOT EXECUTED 10da7a: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10da7c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10da7f: e9 bc 00 00 00 jmp 10db40 <== NOT EXECUTED /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) 10da84: 83 7e 4c 01 cmpl $0x1,0x4c(%esi) 10da88: 0f 84 be 00 00 00 je 10db4c <== ALWAYS TAKEN if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; 10da8e: 89 d6 mov %edx,%esi switch( type ) { 10da90: 83 fb 03 cmp $0x3,%ebx 10da93: 74 1b je 10dab0 10da95: 83 fb 04 cmp $0x4,%ebx 10da98: 0f 84 92 00 00 00 je 10db30 <== NEVER TAKEN 10da9e: 83 fb 02 cmp $0x2,%ebx 10daa1: 74 59 je 10dafc <== NEVER TAKEN /* * Evaluate all tokens until we are done or an error occurs. */ while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) { 10daa3: 83 fb 04 cmp $0x4,%ebx 10daa6: 0f 85 56 ff ff ff jne 10da02 <== ALWAYS TAKEN 10daac: eb 85 jmp 10da33 <== NOT EXECUTED 10daae: 66 90 xchg %ax,%ax <== NOT EXECUTED case IMFS_NAME: /* * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { 10dab0: 8b 42 4c mov 0x4c(%edx),%eax 10dab3: 83 f8 03 cmp $0x3,%eax 10dab6: 0f 84 e0 00 00 00 je 10db9c <== NEVER TAKEN node = pathloc->node_access; if ( !node ) rtems_set_errno_and_return_minus_one( ENOTDIR ); } else if ( node->type == IMFS_SYM_LINK ) { 10dabc: 83 f8 04 cmp $0x4,%eax 10dabf: 0f 84 54 01 00 00 je 10dc19 <== NEVER TAKEN /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10dac5: 48 dec %eax 10dac6: 0f 85 09 01 00 00 jne 10dbd5 <== NEVER TAKEN /* * 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 ) { 10dacc: 8b 46 5c mov 0x5c(%esi),%eax 10dacf: 85 c0 test %eax,%eax 10dad1: 0f 85 13 01 00 00 jne 10dbea <== NEVER TAKEN /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10dad7: 83 ec 08 sub $0x8,%esp 10dada: 8d 7d bf lea -0x41(%ebp),%edi 10dadd: 57 push %edi 10dade: 56 push %esi 10dadf: e8 a4 04 00 00 call 10df88 10dae4: 89 c6 mov %eax,%esi if ( !node ) 10dae6: 83 c4 10 add $0x10,%esp 10dae9: 85 c0 test %eax,%eax 10daeb: 0f 84 cf 00 00 00 je 10dbc0 <== NEVER TAKEN /* * Set the node access to the point we have found. */ pathloc->node_access = node; 10daf1: 8b 45 10 mov 0x10(%ebp),%eax 10daf4: 89 30 mov %esi,(%eax) 10daf6: e9 07 ff ff ff jmp 10da02 10dafb: 90 nop case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10dafc: a1 b4 c4 11 00 mov 0x11c4b4,%eax <== NOT EXECUTED 10db01: 39 50 14 cmp %edx,0x14(%eax) <== NOT EXECUTED 10db04: 0f 84 f8 fe ff ff je 10da02 <== NOT EXECUTED /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == 10db0a: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED 10db0d: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED 10db10: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED 10db13: 0f 84 27 01 00 00 je 10dc40 <== NOT EXECUTED *pathloc = newloc; return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),flags,pathloc); } } else { if ( !node->Parent ) 10db19: 8b 72 08 mov 0x8(%edx),%esi <== NOT EXECUTED 10db1c: 85 f6 test %esi,%esi <== NOT EXECUTED 10db1e: 0f 84 9c 00 00 00 je 10dbc0 <== NOT EXECUTED node = node->Parent; pathloc->node_access = node; } pathloc->node_access = node; 10db24: 8b 7d 10 mov 0x10(%ebp),%edi <== NOT EXECUTED 10db27: 89 37 mov %esi,(%edi) <== NOT EXECUTED 10db29: e9 d4 fe ff ff jmp 10da02 <== NOT EXECUTED 10db2e: 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 ); 10db30: e8 eb 26 00 00 call 110220 <__errno> <== NOT EXECUTED 10db35: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED 10db3b: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10db40: 89 d8 mov %ebx,%eax 10db42: 8d 65 f4 lea -0xc(%ebp),%esp 10db45: 5b pop %ebx 10db46: 5e pop %esi 10db47: 5f pop %edi 10db48: c9 leave 10db49: c3 ret 10db4a: 66 90 xchg %ax,%ax /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10db4c: 83 ec 08 sub $0x8,%esp 10db4f: 6a 01 push $0x1 10db51: ff 75 10 pushl 0x10(%ebp) 10db54: e8 37 fd ff ff call 10d890 10db59: 83 c4 10 add $0x10,%esp 10db5c: 85 c0 test %eax,%eax 10db5e: 74 29 je 10db89 <== NEVER TAKEN 10db60: 8b 45 10 mov 0x10(%ebp),%eax 10db63: 8b 10 mov (%eax),%edx 10db65: e9 24 ff ff ff jmp 10da8e 10db6a: 66 90 xchg %ax,%ax return (*pathloc->ops->evalpath_h)( &pathname[i-len], flags, pathloc ); } else { result = IMFS_Set_handlers( pathloc ); } } else { result = IMFS_Set_handlers( pathloc ); 10db6c: ff 75 10 pushl 0x10(%ebp) 10db6f: e8 cc fc ff ff call 10d840 10db74: 89 c3 mov %eax,%ebx 10db76: 56 push %esi /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( pathloc, flags ) ) 10db77: ff 75 0c pushl 0xc(%ebp) 10db7a: ff 75 10 pushl 0x10(%ebp) 10db7d: e8 0e fd ff ff call 10d890 10db82: 83 c4 10 add $0x10,%esp 10db85: 85 c0 test %eax,%eax 10db87: 75 b7 jne 10db40 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EACCES ); 10db89: e8 92 26 00 00 call 110220 <__errno> <== NOT EXECUTED 10db8e: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10db94: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10db99: eb a5 jmp 10db40 <== NOT EXECUTED 10db9b: 90 nop <== NOT EXECUTED * If we are at a link follow it. */ if ( node->type == IMFS_HARD_LINK ) { IMFS_evaluate_hard_link( pathloc, 0 ); 10db9c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10db9f: 6a 00 push $0x0 <== NOT EXECUTED 10dba1: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dba4: e8 27 fd ff ff call 10d8d0 <== NOT EXECUTED node = pathloc->node_access; 10dba9: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10dbac: 8b 30 mov (%eax),%esi <== NOT EXECUTED if ( !node ) 10dbae: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dbb1: 85 f6 test %esi,%esi <== NOT EXECUTED 10dbb3: 74 20 je 10dbd5 <== NOT EXECUTED } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_sym_link( pathloc, 0 ); node = pathloc->node_access; 10dbb5: 8b 46 4c mov 0x4c(%esi),%eax <== NOT EXECUTED 10dbb8: e9 08 ff ff ff jmp 10dac5 <== NOT EXECUTED 10dbbd: 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 ); 10dbc0: e8 5b 26 00 00 call 110220 <__errno> <== NOT EXECUTED 10dbc5: c7 00 02 00 00 00 movl $0x2,(%eax) <== NOT EXECUTED 10dbcb: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10dbd0: e9 6b ff ff ff jmp 10db40 <== NOT EXECUTED /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) rtems_set_errno_and_return_minus_one( ENOTDIR ); 10dbd5: e8 46 26 00 00 call 110220 <__errno> <== NOT EXECUTED 10dbda: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 10dbe0: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10dbe5: e9 56 ff ff ff jmp 10db40 <== 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; 10dbea: 8d 55 e0 lea -0x20(%ebp),%edx <== NOT EXECUTED 10dbed: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 10dbf0: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10dbf5: 89 d7 mov %edx,%edi <== NOT EXECUTED 10dbf7: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10dbf9: 89 d6 mov %edx,%esi <== NOT EXECUTED 10dbfb: e9 59 fe ff ff jmp 10da59 <== NOT EXECUTED rtems_filesystem_location_info_t newloc; IMFS_jnode_t *node; int result; if ( !rtems_libio_is_valid_perms( flags ) ) { assert( 0 ); 10dc00: 68 c8 82 11 00 push $0x1182c8 <== NOT EXECUTED 10dc05: 68 5c 89 11 00 push $0x11895c <== NOT EXECUTED 10dc0a: 68 ea 01 00 00 push $0x1ea <== NOT EXECUTED 10dc0f: 68 6c 89 11 00 push $0x11896c <== NOT EXECUTED 10dc14: e8 6f 92 ff ff call 106e88 <__assert_func> <== 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 ); 10dc19: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dc1c: 6a 00 push $0x0 <== NOT EXECUTED 10dc1e: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10dc21: e8 02 fd ff ff call 10d928 <== NOT EXECUTED 10dc26: 89 c3 mov %eax,%ebx <== NOT EXECUTED node = pathloc->node_access; 10dc28: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10dc2b: 8b 02 mov (%edx),%eax <== NOT EXECUTED if ( result == -1 ) 10dc2d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10dc30: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED 10dc33: 0f 84 07 ff ff ff je 10db40 <== NOT EXECUTED } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_sym_link( pathloc, 0 ); node = pathloc->node_access; 10dc39: 89 c6 mov %eax,%esi <== NOT EXECUTED 10dc3b: e9 75 ff ff ff jmp 10dbb5 <== 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; 10dc40: 8d 55 e0 lea -0x20(%ebp),%edx <== NOT EXECUTED 10dc43: 8d 70 08 lea 0x8(%eax),%esi <== NOT EXECUTED 10dc46: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10dc4b: 89 d7 mov %edx,%edi <== NOT EXECUTED 10dc4d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10dc4f: 89 d6 mov %edx,%esi <== NOT EXECUTED 10dc51: e9 03 fe ff ff jmp 10da59 <== NOT EXECUTED =============================================================================== 0010dd04 : int IMFS_evaluate_for_make( const char *path, /* IN */ rtems_filesystem_location_info_t *pathloc, /* IN/OUT */ const char **name /* OUT */ ) { 10dd04: 55 push %ebp 10dd05: 89 e5 mov %esp,%ebp 10dd07: 57 push %edi 10dd08: 56 push %esi 10dd09: 53 push %ebx 10dd0a: 83 ec 4c sub $0x4c,%esp /* * This was filled in by the caller and is valid in the * mount table. */ node = pathloc->node_access; 10dd0d: 8b 45 0c mov 0xc(%ebp),%eax 10dd10: 8b 18 mov (%eax),%ebx 10dd12: c7 45 b0 00 00 00 00 movl $0x0,-0x50(%ebp) * Evaluate all tokens until we are done or an error occurs. */ while( !done ) { type = IMFS_get_token( &path[i], token, &len ); 10dd19: 56 push %esi 10dd1a: 8d 55 f0 lea -0x10(%ebp),%edx 10dd1d: 52 push %edx 10dd1e: 8d 4d bf lea -0x41(%ebp),%ecx 10dd21: 51 push %ecx 10dd22: 8b 45 08 mov 0x8(%ebp),%eax 10dd25: 03 45 b0 add -0x50(%ebp),%eax 10dd28: 50 push %eax 10dd29: e8 fe 02 00 00 call 10e02c 10dd2e: 89 c6 mov %eax,%esi i += len; 10dd30: 8b 7d f0 mov -0x10(%ebp),%edi if ( !pathloc->node_access ) 10dd33: 8b 45 0c mov 0xc(%ebp),%eax 10dd36: 8b 10 mov (%eax),%edx 10dd38: 83 c4 10 add $0x10,%esp 10dd3b: 85 d2 test %edx,%edx 10dd3d: 0f 84 1f 01 00 00 je 10de62 <== NEVER TAKEN /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) 10dd43: 85 f6 test %esi,%esi 10dd45: 75 1d jne 10dd64 <== ALWAYS TAKEN pathloc->node_access = node; break; case IMFS_NO_MORE_PATH: rtems_set_errno_and_return_minus_one( EEXIST ); 10dd47: e8 d4 24 00 00 call 110220 <__errno> <== NOT EXECUTED 10dd4c: c7 00 11 00 00 00 movl $0x11,(%eax) <== NOT EXECUTED 10dd52: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10dd57: 89 d8 mov %ebx,%eax 10dd59: 8d 65 f4 lea -0xc(%ebp),%esp 10dd5c: 5b pop %ebx 10dd5d: 5e pop %esi 10dd5e: 5f pop %edi 10dd5f: c9 leave 10dd60: c3 ret 10dd61: 8d 76 00 lea 0x0(%esi),%esi /* * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) 10dd64: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10dd68: 0f 84 0e 01 00 00 je 10de7c <== ALWAYS TAKEN */ while( !done ) { type = IMFS_get_token( &path[i], token, &len ); i += len; 10dd6e: 01 7d b0 add %edi,-0x50(%ebp) if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; 10dd71: 89 d3 mov %edx,%ebx switch( type ) { 10dd73: 83 fe 02 cmp $0x2,%esi 10dd76: 0f 84 88 00 00 00 je 10de04 <== NEVER TAKEN 10dd7c: 76 26 jbe 10dda4 10dd7e: 83 fe 03 cmp $0x3,%esi 10dd81: 74 2d je 10ddb0 <== ALWAYS TAKEN 10dd83: 83 fe 04 cmp $0x4,%esi <== NOT EXECUTED 10dd86: 75 91 jne 10dd19 <== 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 ); 10dd88: e8 93 24 00 00 call 110220 <__errno> <== NOT EXECUTED 10dd8d: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED 10dd93: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10dd98: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10dd9a: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dd9d: 5b pop %ebx <== NOT EXECUTED 10dd9e: 5e pop %esi <== NOT EXECUTED 10dd9f: 5f pop %edi <== NOT EXECUTED 10dda0: c9 leave <== NOT EXECUTED 10dda1: c3 ret <== NOT EXECUTED 10dda2: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) rtems_set_errno_and_return_minus_one( EACCES ); node = pathloc->node_access; switch( type ) { 10dda4: 85 f6 test %esi,%esi 10dda6: 74 9f je 10dd47 <== NEVER TAKEN 10dda8: e9 6c ff ff ff jmp 10dd19 10ddad: 8d 76 00 lea 0x0(%esi),%esi pathloc->node_access = node; break; case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { 10ddb0: 8b 42 4c mov 0x4c(%edx),%eax 10ddb3: 83 f8 03 cmp $0x3,%eax 10ddb6: 0f 84 74 01 00 00 je 10df30 <== NEVER TAKEN result = IMFS_evaluate_link( pathloc, 0 ); if ( result == -1 ) return -1; } else if ( node->type == IMFS_SYM_LINK ) { 10ddbc: 83 f8 04 cmp $0x4,%eax 10ddbf: 0f 84 90 01 00 00 je 10df55 <== NEVER TAKEN if ( result == -1 ) return -1; } node = pathloc->node_access; if ( !node ) 10ddc5: 85 db test %ebx,%ebx 10ddc7: 0f 84 12 01 00 00 je 10dedf <== NEVER TAKEN /* * Only a directory can be decended into. */ if ( node->type != IMFS_DIRECTORY ) 10ddcd: 83 7b 4c 01 cmpl $0x1,0x4c(%ebx) 10ddd1: 0f 85 08 01 00 00 jne 10dedf <== NEVER TAKEN /* * 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 ) { 10ddd7: 8b 43 5c mov 0x5c(%ebx),%eax 10ddda: 85 c0 test %eax,%eax 10dddc: 0f 85 12 01 00 00 jne 10def4 <== NEVER TAKEN /* * Otherwise find the token name in the present location. */ node = IMFS_find_match_in_dir( node, token ); 10dde2: 83 ec 08 sub $0x8,%esp 10dde5: 8d 45 bf lea -0x41(%ebp),%eax 10dde8: 50 push %eax 10dde9: 53 push %ebx 10ddea: e8 99 01 00 00 call 10df88 10ddef: 89 c3 mov %eax,%ebx /* * If there is no node we have found the name of the node we * wish to create. */ if ( ! node ) 10ddf1: 83 c4 10 add $0x10,%esp 10ddf4: 85 c0 test %eax,%eax 10ddf6: 74 3c je 10de34 done = true; else pathloc->node_access = node; 10ddf8: 8b 55 0c mov 0xc(%ebp),%edx 10ddfb: 89 02 mov %eax,(%edx) 10ddfd: e9 17 ff ff ff jmp 10dd19 10de02: 66 90 xchg %ax,%ax case IMFS_UP_DIR: /* * Am I at the root of all filesystems? (chroot'ed?) */ if ( pathloc->node_access == rtems_filesystem_root.node_access ) 10de04: a1 b4 c4 11 00 mov 0x11c4b4,%eax <== NOT EXECUTED 10de09: 39 50 14 cmp %edx,0x14(%eax) <== NOT EXECUTED 10de0c: 0f 84 07 ff ff ff je 10dd19 <== NOT EXECUTED /* * Am I at the root of this mounted filesystem? */ if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){ 10de12: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10de15: 8b 41 0c mov 0xc(%ecx),%eax <== NOT EXECUTED 10de18: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED 10de1b: 0f 84 5b 01 00 00 je 10df7c <== NOT EXECUTED *pathloc = newloc; return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); } } else { if ( !node->Parent ) 10de21: 8b 5a 08 mov 0x8(%edx),%ebx <== NOT EXECUTED 10de24: 85 db test %ebx,%ebx <== NOT EXECUTED 10de26: 74 3a je 10de62 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOENT ); node = node->Parent; } pathloc->node_access = node; 10de28: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10de2b: 89 18 mov %ebx,(%eax) <== NOT EXECUTED 10de2d: e9 e7 fe ff ff jmp 10dd19 <== NOT EXECUTED 10de32: 66 90 xchg %ax,%ax <== NOT EXECUTED case IMFS_CURRENT_DIR: break; } } *name = &path[ i - len ]; 10de34: 8b 45 b0 mov -0x50(%ebp),%eax 10de37: 2b 45 f0 sub -0x10(%ebp),%eax 10de3a: 03 45 08 add 0x8(%ebp),%eax 10de3d: 8b 4d 10 mov 0x10(%ebp),%ecx 10de40: 89 01 mov %eax,(%ecx) /* * 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++) { 10de42: 8b 45 08 mov 0x8(%ebp),%eax 10de45: 03 45 b0 add -0x50(%ebp),%eax 10de48: 8a 10 mov (%eax),%dl 10de4a: 84 d2 test %dl,%dl 10de4c: 75 0a jne 10de58 <== NEVER TAKEN 10de4e: eb 4c jmp 10de9c 10de50: 8a 50 01 mov 0x1(%eax),%dl <== NOT EXECUTED 10de53: 40 inc %eax <== NOT EXECUTED 10de54: 84 d2 test %dl,%dl <== NOT EXECUTED 10de56: 74 44 je 10de9c <== NOT EXECUTED if ( !IMFS_is_separator( path[ i ] ) ) 10de58: 80 fa 2f cmp $0x2f,%dl <== NOT EXECUTED 10de5b: 74 f3 je 10de50 <== NOT EXECUTED 10de5d: 80 fa 5c cmp $0x5c,%dl <== NOT EXECUTED 10de60: 74 ee je 10de50 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOENT ); 10de62: e8 b9 23 00 00 call 110220 <__errno> <== NOT EXECUTED 10de67: c7 00 02 00 00 00 movl $0x2,(%eax) <== NOT EXECUTED 10de6d: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10de72: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10de74: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10de77: 5b pop %ebx <== NOT EXECUTED 10de78: 5e pop %esi <== NOT EXECUTED 10de79: 5f pop %edi <== NOT EXECUTED 10de7a: c9 leave <== NOT EXECUTED 10de7b: c3 ret <== NOT EXECUTED * I cannot move out of this directory without execute permission. */ if ( type != IMFS_NO_MORE_PATH ) if ( node->type == IMFS_DIRECTORY ) if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) ) 10de7c: 83 ec 08 sub $0x8,%esp 10de7f: 6a 01 push $0x1 10de81: ff 75 0c pushl 0xc(%ebp) 10de84: e8 07 fa ff ff call 10d890 10de89: 83 c4 10 add $0x10,%esp 10de8c: 85 c0 test %eax,%eax 10de8e: 74 3a je 10deca <== NEVER TAKEN 10de90: 8b 4d 0c mov 0xc(%ebp),%ecx 10de93: 8b 11 mov (%ecx),%edx 10de95: e9 d4 fe ff ff jmp 10dd6e 10de9a: 66 90 xchg %ax,%ax /* * Verify we can execute and write to this directory. */ result = IMFS_Set_handlers( pathloc ); 10de9c: ff 75 0c pushl 0xc(%ebp) 10de9f: e8 9c f9 ff ff call 10d840 10dea4: 89 c3 mov %eax,%ebx /* * The returned node must be a directory */ node = pathloc->node_access; if ( node->type != IMFS_DIRECTORY ) 10dea6: 8b 55 0c mov 0xc(%ebp),%edx 10dea9: 8b 02 mov (%edx),%eax 10deab: 5a pop %edx 10deac: 83 78 4c 01 cmpl $0x1,0x4c(%eax) 10deb0: 75 2d jne 10dedf <== NEVER TAKEN /* * We must have Write and execute permission on the returned node. */ if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) ) 10deb2: 83 ec 08 sub $0x8,%esp 10deb5: 6a 03 push $0x3 10deb7: ff 75 0c pushl 0xc(%ebp) 10deba: e8 d1 f9 ff ff call 10d890 10debf: 83 c4 10 add $0x10,%esp 10dec2: 85 c0 test %eax,%eax 10dec4: 0f 85 8d fe ff ff jne 10dd57 <== ALWAYS TAKEN rtems_set_errno_and_return_minus_one( EACCES ); 10deca: e8 51 23 00 00 call 110220 <__errno> <== NOT EXECUTED 10decf: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10ded5: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10deda: e9 78 fe ff ff jmp 10dd57 <== 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 ); 10dedf: e8 3c 23 00 00 call 110220 <__errno> <== NOT EXECUTED 10dee4: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED 10deea: bb ff ff ff ff mov $0xffffffff,%ebx <== NOT EXECUTED 10deef: e9 63 fe ff ff jmp 10dd57 <== 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; 10def4: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 10def7: 8d 70 18 lea 0x18(%eax),%esi <== NOT EXECUTED 10defa: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10deff: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED *pathloc = newloc; 10df01: 8d 75 e0 lea -0x20(%ebp),%esi <== NOT EXECUTED 10df04: b1 04 mov $0x4,%cl <== NOT EXECUTED 10df06: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10df09: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name ); 10df0b: 51 push %ecx <== NOT EXECUTED 10df0c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10df0f: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10df12: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 10df15: 50 push %eax <== NOT EXECUTED 10df16: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 10df19: 29 4d b0 sub %ecx,-0x50(%ebp) <== NOT EXECUTED 10df1c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10df1f: 03 45 b0 add -0x50(%ebp),%eax <== NOT EXECUTED 10df22: 50 push %eax <== NOT EXECUTED 10df23: ff 52 04 call *0x4(%edx) <== NOT EXECUTED 10df26: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10df28: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10df2b: e9 27 fe ff ff jmp 10dd57 <== NOT EXECUTED case IMFS_NAME: if ( node->type == IMFS_HARD_LINK ) { result = IMFS_evaluate_link( pathloc, 0 ); 10df30: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10df33: 6a 00 push $0x0 <== NOT EXECUTED 10df35: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10df38: e8 1b fd ff ff call 10dc58 <== NOT EXECUTED 10df3d: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( result == -1 ) 10df3f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10df42: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10df45: 0f 84 0c fe ff ff je 10dd57 <== NOT EXECUTED 10df4b: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10df4e: 8b 1a mov (%edx),%ebx <== NOT EXECUTED 10df50: e9 70 fe ff ff jmp 10ddc5 <== NOT EXECUTED return -1; } else if ( node->type == IMFS_SYM_LINK ) { result = IMFS_evaluate_link( pathloc, 0 ); 10df55: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10df58: 6a 00 push $0x0 <== NOT EXECUTED 10df5a: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10df5d: e8 f6 fc ff ff call 10dc58 <== NOT EXECUTED 10df62: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( result == -1 ) 10df64: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10df67: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 10df6a: 0f 84 e7 fd ff ff je 10dd57 <== NOT EXECUTED 10df70: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10df73: 8b 19 mov (%ecx),%ebx <== NOT EXECUTED 10df75: e9 4b fe ff ff jmp 10ddc5 <== NOT EXECUTED 10df7a: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( pathloc->node_access == rtems_filesystem_root.node_access ) { break; } else { newloc = pathloc->mt_entry->mt_point_node; 10df7c: 8d 7d e0 lea -0x20(%ebp),%edi <== NOT EXECUTED 10df7f: 8d 70 08 lea 0x8(%eax),%esi <== NOT EXECUTED 10df82: e9 73 ff ff ff jmp 10defa <== NOT EXECUTED =============================================================================== 0010d8d0 : int IMFS_evaluate_hard_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10d8d0: 55 push %ebp <== NOT EXECUTED 10d8d1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d8d3: 53 push %ebx <== NOT EXECUTED 10d8d4: 83 ec 04 sub $0x4,%esp <== NOT EXECUTED 10d8d7: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *jnode = node->node_access; 10d8da: 8b 03 mov (%ebx),%eax <== NOT EXECUTED /* * Check for things that should never happen. */ if ( jnode->type != IMFS_HARD_LINK ) 10d8dc: 83 78 4c 03 cmpl $0x3,0x4c(%eax) <== NOT EXECUTED 10d8e0: 75 38 jne 10d91a <== NOT EXECUTED /* * Set the hard link value and the handlers. */ node->node_access = jnode->info.hard_link.link_node; 10d8e2: 8b 40 50 mov 0x50(%eax),%eax <== NOT EXECUTED 10d8e5: 89 03 mov %eax,(%ebx) <== NOT EXECUTED IMFS_Set_handlers( node ); 10d8e7: 53 push %ebx <== NOT EXECUTED 10d8e8: e8 53 ff ff ff call 10d840 <== NOT EXECUTED /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 10d8ed: 50 push %eax <== NOT EXECUTED 10d8ee: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10d8f1: 53 push %ebx <== NOT EXECUTED 10d8f2: e8 99 ff ff ff call 10d890 <== NOT EXECUTED 10d8f7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d8fa: 85 c0 test %eax,%eax <== NOT EXECUTED 10d8fc: 74 0a je 10d908 <== NOT EXECUTED 10d8fe: 31 c0 xor %eax,%eax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10d900: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10d903: c9 leave <== NOT EXECUTED 10d904: c3 ret <== NOT EXECUTED 10d905: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); 10d908: e8 13 29 00 00 call 110220 <__errno> <== NOT EXECUTED 10d90d: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10d913: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10d918: eb e6 jmp 10d900 <== NOT EXECUTED /* * Check for things that should never happen. */ if ( jnode->type != IMFS_HARD_LINK ) rtems_fatal_error_occurred (0xABCD0000); 10d91a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d91d: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED 10d922: e8 5d d1 ff ff call 10aa84 <== NOT EXECUTED =============================================================================== 0010dc58 : int IMFS_evaluate_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10dc58: 55 push %ebp <== NOT EXECUTED 10dc59: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10dc5b: 57 push %edi <== NOT EXECUTED 10dc5c: 56 push %esi <== NOT EXECUTED 10dc5d: 53 push %ebx <== NOT EXECUTED 10dc5e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10dc61: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 10dc64: 8b 7d 0c mov 0xc(%ebp),%edi <== NOT EXECUTED 10dc67: 8b 15 b4 c4 11 00 mov 0x11c4b4,%edx <== NOT EXECUTED 10dc6d: eb 0e jmp 10dc7d <== NOT EXECUTED 10dc6f: 90 nop <== NOT EXECUTED */ if ( jnode->type == IMFS_HARD_LINK ) result = IMFS_evaluate_hard_link( node, flags ); else if (jnode->type == IMFS_SYM_LINK ) 10dc70: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10dc73: 74 53 je 10dcc8 <== NOT EXECUTED result = IMFS_evaluate_sym_link( node, flags ); } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || ( jnode->type == IMFS_HARD_LINK ) ) ); 10dc75: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED 10dc78: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10dc7b: 77 3a ja 10dcb7 <== NOT EXECUTED { IMFS_jnode_t *jnode; int result = 0; do { jnode = node->node_access; 10dc7d: 8b 1e mov (%esi),%ebx <== NOT EXECUTED /* * Increment and check the link counter. */ rtems_filesystem_link_counts ++; 10dc7f: 8b 42 28 mov 0x28(%edx),%eax <== NOT EXECUTED 10dc82: 40 inc %eax <== NOT EXECUTED 10dc83: 66 89 42 28 mov %ax,0x28(%edx) <== NOT EXECUTED if ( rtems_filesystem_link_counts > MAXSYMLINK ) { 10dc87: 66 83 f8 05 cmp $0x5,%ax <== NOT EXECUTED 10dc8b: 77 57 ja 10dce4 <== NOT EXECUTED /* * Follow the Link node. */ if ( jnode->type == IMFS_HARD_LINK ) 10dc8d: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10dc90: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10dc93: 75 db jne 10dc70 <== NOT EXECUTED result = IMFS_evaluate_hard_link( node, flags ); 10dc95: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dc98: 57 push %edi <== NOT EXECUTED 10dc99: 56 push %esi <== NOT EXECUTED 10dc9a: e8 31 fc ff ff call 10d8d0 <== NOT EXECUTED 10dc9f: 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 ) ) ); 10dca2: 85 c0 test %eax,%eax <== NOT EXECUTED 10dca4: 75 33 jne 10dcd9 <== NOT EXECUTED 10dca6: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10dca9: 8b 15 b4 c4 11 00 mov 0x11c4b4,%edx <== NOT EXECUTED 10dcaf: 83 e8 03 sub $0x3,%eax <== NOT EXECUTED 10dcb2: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 10dcb5: 76 c6 jbe 10dc7d <== NOT EXECUTED 10dcb7: 31 c0 xor %eax,%eax <== NOT EXECUTED /* * Clear link counter. */ rtems_filesystem_link_counts = 0; 10dcb9: 66 c7 42 28 00 00 movw $0x0,0x28(%edx) <== NOT EXECUTED return result; } 10dcbf: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dcc2: 5b pop %ebx <== NOT EXECUTED 10dcc3: 5e pop %esi <== NOT EXECUTED 10dcc4: 5f pop %edi <== NOT EXECUTED 10dcc5: c9 leave <== NOT EXECUTED 10dcc6: c3 ret <== NOT EXECUTED 10dcc7: 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 ); 10dcc8: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10dccb: 57 push %edi <== NOT EXECUTED 10dccc: 56 push %esi <== NOT EXECUTED 10dccd: e8 56 fc ff ff call 10d928 <== NOT EXECUTED 10dcd2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } while ( ( result == 0 ) && ( ( jnode->type == IMFS_SYM_LINK ) || ( jnode->type == IMFS_HARD_LINK ) ) ); 10dcd5: 85 c0 test %eax,%eax <== NOT EXECUTED 10dcd7: 74 cd je 10dca6 <== NOT EXECUTED 10dcd9: 8b 15 b4 c4 11 00 mov 0x11c4b4,%edx <== NOT EXECUTED 10dcdf: eb d8 jmp 10dcb9 <== NOT EXECUTED 10dce1: 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; 10dce4: 66 c7 42 28 00 00 movw $0x0,0x28(%edx) <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ELOOP ); 10dcea: e8 31 25 00 00 call 110220 <__errno> <== NOT EXECUTED 10dcef: c7 00 5c 00 00 00 movl $0x5c,(%eax) <== NOT EXECUTED 10dcf5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED */ rtems_filesystem_link_counts = 0; return result; } 10dcfa: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dcfd: 5b pop %ebx <== NOT EXECUTED 10dcfe: 5e pop %esi <== NOT EXECUTED 10dcff: 5f pop %edi <== NOT EXECUTED 10dd00: c9 leave <== NOT EXECUTED 10dd01: c3 ret <== NOT EXECUTED =============================================================================== 0010d890 : int IMFS_evaluate_permission( rtems_filesystem_location_info_t *node, int flags ) { 10d890: 55 push %ebp 10d891: 89 e5 mov %esp,%ebp 10d893: 83 ec 08 sub $0x8,%esp uid_t st_uid; gid_t st_gid; IMFS_jnode_t *jnode; int flags_to_test; if ( !rtems_libio_is_valid_perms( flags ) ) 10d896: f7 45 0c f8 ff ff ff testl $0xfffffff8,0xc(%ebp) 10d89d: 75 1d jne 10d8bc <== NEVER TAKEN /* * If all of the flags are set we have permission * to do this. */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) 10d89f: 8b 55 0c mov 0xc(%ebp),%edx 10d8a2: c1 e2 06 shl $0x6,%edx 10d8a5: 8b 4d 08 mov 0x8(%ebp),%ecx 10d8a8: 8b 01 mov (%ecx),%eax 10d8aa: 8b 40 30 mov 0x30(%eax),%eax 10d8ad: 21 d0 and %edx,%eax 10d8af: 39 c2 cmp %eax,%edx 10d8b1: 0f 94 c0 sete %al 10d8b4: 0f b6 c0 movzbl %al,%eax return 1; return 0; } 10d8b7: c9 leave 10d8b8: c3 ret 10d8b9: 8d 76 00 lea 0x0(%esi),%esi gid_t st_gid; IMFS_jnode_t *jnode; int flags_to_test; if ( !rtems_libio_is_valid_perms( flags ) ) rtems_set_errno_and_return_minus_one( EPERM ); 10d8bc: e8 5f 29 00 00 call 110220 <__errno> <== NOT EXECUTED 10d8c1: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10d8c7: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED */ if ( ( flags_to_test & jnode->st_mode) == flags_to_test ) return 1; return 0; } 10d8cc: c9 leave <== NOT EXECUTED 10d8cd: c3 ret <== NOT EXECUTED =============================================================================== 0010d928 : int IMFS_evaluate_sym_link( rtems_filesystem_location_info_t *node, /* IN/OUT */ int flags /* IN */ ) { 10d928: 55 push %ebp <== NOT EXECUTED 10d929: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10d92b: 57 push %edi <== NOT EXECUTED 10d92c: 56 push %esi <== NOT EXECUTED 10d92d: 53 push %ebx <== NOT EXECUTED 10d92e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d931: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED IMFS_jnode_t *jnode = node->node_access; 10d934: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10d937: 8b 02 mov (%edx),%eax <== NOT EXECUTED /* * Check for things that should never happen. */ if ( jnode->type != IMFS_SYM_LINK ) 10d939: 83 78 4c 04 cmpl $0x4,0x4c(%eax) <== NOT EXECUTED 10d93d: 0f 85 83 00 00 00 jne 10d9c6 <== NOT EXECUTED rtems_fatal_error_occurred (0xABCD0000); if ( !jnode->Parent ) 10d943: 8b 50 08 mov 0x8(%eax),%edx <== NOT EXECUTED 10d946: 85 d2 test %edx,%edx <== NOT EXECUTED 10d948: 0f 84 85 00 00 00 je 10d9d3 <== 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; 10d94e: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 10d951: 89 11 mov %edx,(%ecx) <== NOT EXECUTED rtems_filesystem_get_sym_start_loc( 10d953: 8b 50 50 mov 0x50(%eax),%edx <== NOT EXECUTED 10d956: 8a 02 mov (%edx),%al <== NOT EXECUTED 10d958: 3c 2f cmp $0x2f,%al <== NOT EXECUTED 10d95a: 74 0c je 10d968 <== NOT EXECUTED 10d95c: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 10d95e: 74 08 je 10d968 <== NOT EXECUTED 10d960: 84 c0 test %al,%al <== NOT EXECUTED 10d962: 74 04 je 10d968 <== NOT EXECUTED 10d964: 31 c0 xor %eax,%eax <== NOT EXECUTED 10d966: eb 17 jmp 10d97f <== NOT EXECUTED 10d968: a1 b4 c4 11 00 mov 0x11c4b4,%eax <== NOT EXECUTED 10d96d: 8d 70 14 lea 0x14(%eax),%esi <== NOT EXECUTED 10d970: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10d975: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 10d978: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 10d97a: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED /* * Use eval path to evaluate the path of the symbolic link. */ result = IMFS_eval_path( 10d97f: 51 push %ecx <== NOT EXECUTED 10d980: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d983: 53 push %ebx <== NOT EXECUTED 10d984: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED 10d987: 50 push %eax <== NOT EXECUTED 10d988: e8 53 00 00 00 call 10d9e0 <== NOT EXECUTED 10d98d: 89 c6 mov %eax,%esi <== NOT EXECUTED &jnode->info.sym_link.name[i], flags, node ); IMFS_Set_handlers( node ); 10d98f: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d992: e8 a9 fe ff ff call 10d840 <== NOT EXECUTED /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) 10d997: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10d99a: 53 push %ebx <== NOT EXECUTED 10d99b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10d99e: e8 ed fe ff ff call 10d890 <== NOT EXECUTED 10d9a3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d9a6: 85 c0 test %eax,%eax <== NOT EXECUTED 10d9a8: 74 0a je 10d9b4 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EACCES ); return result; } 10d9aa: 89 f0 mov %esi,%eax <== NOT EXECUTED 10d9ac: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d9af: 5b pop %ebx <== NOT EXECUTED 10d9b0: 5e pop %esi <== NOT EXECUTED 10d9b1: 5f pop %edi <== NOT EXECUTED 10d9b2: c9 leave <== NOT EXECUTED 10d9b3: c3 ret <== NOT EXECUTED /* * Verify we have the correct permissions for this node. */ if ( !IMFS_evaluate_permission( node, flags ) ) rtems_set_errno_and_return_minus_one( EACCES ); 10d9b4: e8 67 28 00 00 call 110220 <__errno> <== NOT EXECUTED 10d9b9: c7 00 0d 00 00 00 movl $0xd,(%eax) <== NOT EXECUTED 10d9bf: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 10d9c4: eb e4 jmp 10d9aa <== NOT EXECUTED /* * Check for things that should never happen. */ if ( jnode->type != IMFS_SYM_LINK ) rtems_fatal_error_occurred (0xABCD0000); 10d9c6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d9c9: 68 00 00 cd ab push $0xabcd0000 <== NOT EXECUTED 10d9ce: e8 b1 d0 ff ff call 10aa84 <== NOT EXECUTED if ( !jnode->Parent ) rtems_fatal_error_occurred( 0xBAD00000 ); 10d9d3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d9d6: 68 00 00 d0 ba push $0xbad00000 <== NOT EXECUTED 10d9db: e8 a4 d0 ff ff call 10aa84 <== NOT EXECUTED =============================================================================== 0010fc0c : int IMFS_fchmod( rtems_filesystem_location_info_t *loc, mode_t mode ) { 10fc0c: 55 push %ebp <== NOT EXECUTED 10fc0d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fc0f: 53 push %ebx <== NOT EXECUTED 10fc10: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 10fc13: 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; 10fc16: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10fc19: 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 ) ) ) 10fc1b: f7 c2 00 fe ff ff test $0xfffffe00,%edx <== NOT EXECUTED 10fc21: 75 2d jne 10fc50 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EPERM ); jnode->st_mode &= ~(S_IRWXU | S_IRWXG | S_IRWXO); jnode->st_mode |= mode; 10fc23: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10fc26: 25 00 fe ff ff and $0xfffffe00,%eax <== NOT EXECUTED 10fc2b: 09 c2 or %eax,%edx <== NOT EXECUTED 10fc2d: 89 53 30 mov %edx,0x30(%ebx) <== NOT EXECUTED IMFS_update_ctime( jnode ); 10fc30: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10fc33: 6a 00 push $0x0 <== NOT EXECUTED 10fc35: 8d 45 f4 lea -0xc(%ebp),%eax <== NOT EXECUTED 10fc38: 50 push %eax <== NOT EXECUTED 10fc39: e8 16 ea ff ff call 10e654 <== NOT EXECUTED 10fc3e: 8b 45 f4 mov -0xc(%ebp),%eax <== NOT EXECUTED 10fc41: 89 43 48 mov %eax,0x48(%ebx) <== NOT EXECUTED 10fc44: 31 c0 xor %eax,%eax <== NOT EXECUTED 10fc46: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; } 10fc49: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10fc4c: c9 leave <== NOT EXECUTED 10fc4d: c3 ret <== NOT EXECUTED 10fc4e: 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 ); 10fc50: e8 cb 05 00 00 call 110220 <__errno> <== NOT EXECUTED 10fc55: c7 00 01 00 00 00 movl $0x1,(%eax) <== NOT EXECUTED 10fc5b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10fc60: eb e7 jmp 10fc49 <== NOT EXECUTED =============================================================================== 0010df88 : IMFS_jnode_t *IMFS_find_match_in_dir( IMFS_jnode_t *directory, char *name ) { 10df88: 55 push %ebp 10df89: 89 e5 mov %esp,%ebp 10df8b: 57 push %edi 10df8c: 56 push %esi 10df8d: 53 push %ebx 10df8e: 83 ec 0c sub $0xc,%esp 10df91: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Check for fatal errors. A NULL directory show a problem in the * the IMFS code. */ assert( directory ); 10df94: 85 db test %ebx,%ebx 10df96: 74 50 je 10dfe8 <== NEVER TAKEN if ( !name ) 10df98: 8b 45 0c mov 0xc(%ebp),%eax 10df9b: 85 c0 test %eax,%eax 10df9d: 74 3d je 10dfdc <== NEVER TAKEN /* * Check for "." and ".." */ if ( !strcmp( name, dotname ) ) 10df9f: bf 16 8a 11 00 mov $0x118a16,%edi 10dfa4: b9 02 00 00 00 mov $0x2,%ecx 10dfa9: 8b 75 0c mov 0xc(%ebp),%esi 10dfac: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10dfae: 75 0c jne 10dfbc <== ALWAYS TAKEN if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10dfb0: 89 d8 mov %ebx,%eax 10dfb2: 8d 65 f4 lea -0xc(%ebp),%esp 10dfb5: 5b pop %ebx 10dfb6: 5e pop %esi 10dfb7: 5f pop %edi 10dfb8: c9 leave 10dfb9: c3 ret 10dfba: 66 90 xchg %ax,%ax */ if ( !strcmp( name, dotname ) ) return directory; if ( !strcmp( name, dotdotname ) ) 10dfbc: bf 18 8a 11 00 mov $0x118a18,%edi 10dfc1: b9 03 00 00 00 mov $0x3,%ecx 10dfc6: 8b 75 0c mov 0xc(%ebp),%esi 10dfc9: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10dfcb: 75 31 jne 10dffe <== ALWAYS TAKEN return directory->Parent; 10dfcd: 8b 5b 08 mov 0x8(%ebx),%ebx <== NOT EXECUTED if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10dfd0: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10dfd2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10dfd5: 5b pop %ebx <== NOT EXECUTED 10dfd6: 5e pop %esi <== NOT EXECUTED 10dfd7: 5f pop %edi <== NOT EXECUTED 10dfd8: c9 leave <== NOT EXECUTED 10dfd9: c3 ret <== NOT EXECUTED 10dfda: 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 ); 10dfdc: 31 db xor %ebx,%ebx if ( !strcmp( name, the_jnode->name ) ) return the_jnode; } return 0; } 10dfde: 89 d8 mov %ebx,%eax 10dfe0: 8d 65 f4 lea -0xc(%ebp),%esp 10dfe3: 5b pop %ebx 10dfe4: 5e pop %esi 10dfe5: 5f pop %edi 10dfe6: c9 leave 10dfe7: c3 ret /* * Check for fatal errors. A NULL directory show a problem in the * the IMFS code. */ assert( directory ); 10dfe8: 68 ba 89 11 00 push $0x1189ba <== NOT EXECUTED 10dfed: 68 1b 8a 11 00 push $0x118a1b <== NOT EXECUTED 10dff2: 6a 2a push $0x2a <== NOT EXECUTED 10dff4: 68 c4 89 11 00 push $0x1189c4 <== NOT EXECUTED 10dff9: e8 8a 8e ff ff call 106e88 <__assert_func> <== NOT EXECUTED if ( !strcmp( name, dotdotname ) ) return directory->Parent; the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; 10dffe: 8b 7b 50 mov 0x50(%ebx),%edi * @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 10e001: 83 c3 54 add $0x54,%ebx !rtems_chain_is_tail( the_chain, the_node ); 10e004: 39 df cmp %ebx,%edi 10e006: 75 0a jne 10e012 10e008: eb d2 jmp 10dfdc 10e00a: 66 90 xchg %ax,%ax the_node = the_node->next ) { 10e00c: 8b 3f mov (%edi),%edi return directory->Parent; the_chain = &directory->info.directory.Entries; for ( the_node = the_chain->first; !rtems_chain_is_tail( the_chain, the_node ); 10e00e: 39 df cmp %ebx,%edi 10e010: 74 ca je 10dfdc <== ALWAYS TAKEN the_node = the_node->next ) { the_jnode = (IMFS_jnode_t *) the_node; if ( !strcmp( name, the_jnode->name ) ) 10e012: 8d 47 0c lea 0xc(%edi),%eax 10e015: 83 ec 08 sub $0x8,%esp 10e018: 50 push %eax 10e019: ff 75 0c pushl 0xc(%ebp) 10e01c: e8 a7 32 00 00 call 1112c8 10e021: 83 c4 10 add $0x10,%esp 10e024: 85 c0 test %eax,%eax 10e026: 75 e4 jne 10e00c 10e028: 89 fb mov %edi,%ebx 10e02a: eb 84 jmp 10dfb0 =============================================================================== 0010e02c : IMFS_token_types IMFS_get_token( const char *path, char *token, int *token_len ) { 10e02c: 55 push %ebp 10e02d: 89 e5 mov %esp,%ebp 10e02f: 57 push %edi 10e030: 56 push %esi 10e031: 53 push %ebx 10e032: 83 ec 08 sub $0x8,%esp 10e035: 8b 4d 08 mov 0x8(%ebp),%ecx 10e038: 8b 5d 0c mov 0xc(%ebp),%ebx register char c; /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; 10e03b: 8a 01 mov (%ecx),%al while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) { 10e03d: 3c 2f cmp $0x2f,%al 10e03f: 0f 84 99 00 00 00 je 10e0de 10e045: 3c 5c cmp $0x5c,%al 10e047: 0f 84 91 00 00 00 je 10e0de <== NEVER TAKEN 10e04d: 84 c0 test %al,%al 10e04f: 0f 84 a2 00 00 00 je 10e0f7 token[i] = c; 10e055: 88 03 mov %al,(%ebx) 10e057: 31 d2 xor %edx,%edx 10e059: eb 06 jmp 10e061 10e05b: 90 nop 10e05c: 88 04 13 mov %al,(%ebx,%edx,1) if ( i == IMFS_NAME_MAX ) 10e05f: 74 3f je 10e0a0 <== NEVER TAKEN return IMFS_INVALID_TOKEN; if ( !IMFS_is_valid_name_char(c) ) type = IMFS_INVALID_TOKEN; c = path [++i]; 10e061: 42 inc %edx 10e062: 8a 04 11 mov (%ecx,%edx,1),%al /* * Copy a name into token. (Remember NULL is a token.) */ c = path[i]; while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) { 10e065: 3c 2f cmp $0x2f,%al 10e067: 74 0d je 10e076 10e069: 3c 5c cmp $0x5c,%al 10e06b: 74 09 je 10e076 <== NEVER TAKEN 10e06d: 84 c0 test %al,%al 10e06f: 74 05 je 10e076 10e071: 83 fa 20 cmp $0x20,%edx 10e074: 7e e6 jle 10e05c <== ALWAYS TAKEN i++; type = IMFS_CURRENT_DIR; } else { type = IMFS_NO_MORE_PATH; } } else if (token[ i-1 ] != '\0') { 10e076: 80 7c 13 ff 00 cmpb $0x0,-0x1(%ebx,%edx,1) 10e07b: 75 33 jne 10e0b0 <== ALWAYS TAKEN /* * Set token_len to the number of characters copied. */ *token_len = i; 10e07d: 8b 45 10 mov 0x10(%ebp),%eax 10e080: 89 10 mov %edx,(%eax) * If we copied something that was not a seperator see if * it was a special name. */ if ( type == IMFS_NAME ) { if ( strcmp( token, "..") == 0 ) 10e082: bf 93 84 11 00 mov $0x118493,%edi 10e087: b9 03 00 00 00 mov $0x3,%ecx 10e08c: 89 de mov %ebx,%esi 10e08e: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10e090: 75 26 jne 10e0b8 <== ALWAYS TAKEN 10e092: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; } return type; } 10e097: 83 c4 08 add $0x8,%esp 10e09a: 5b pop %ebx 10e09b: 5e pop %esi 10e09c: 5f pop %edi 10e09d: c9 leave 10e09e: c3 ret 10e09f: 90 nop c = path[i]; while ( (!IMFS_is_separator(c)) && (i <= IMFS_NAME_MAX) ) { token[i] = c; if ( i == IMFS_NAME_MAX ) 10e0a0: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; } return type; } 10e0a5: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10e0a8: 5b pop %ebx <== NOT EXECUTED 10e0a9: 5e pop %esi <== NOT EXECUTED 10e0aa: 5f pop %edi <== NOT EXECUTED 10e0ab: c9 leave <== NOT EXECUTED 10e0ac: c3 ret <== NOT EXECUTED 10e0ad: 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'; 10e0b0: c6 04 13 00 movb $0x0,(%ebx,%edx,1) 10e0b4: eb c7 jmp 10e07d 10e0b6: 66 90 xchg %ax,%ax */ if ( type == IMFS_NAME ) { if ( strcmp( token, "..") == 0 ) type = IMFS_UP_DIR; else if ( strcmp( token, "." ) == 0 ) 10e0b8: bf 94 84 11 00 mov $0x118494,%edi 10e0bd: b9 02 00 00 00 mov $0x2,%ecx 10e0c2: 89 de mov %ebx,%esi 10e0c4: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10e0c6: 0f 97 c0 seta %al 10e0c9: 0f 92 c2 setb %dl 10e0cc: 28 d0 sub %dl,%al 10e0ce: 0f be c0 movsbl %al,%eax 10e0d1: 83 f8 01 cmp $0x1,%eax 10e0d4: 19 c0 sbb %eax,%eax 10e0d6: 83 e0 fe and $0xfffffffe,%eax 10e0d9: 83 c0 03 add $0x3,%eax 10e0dc: eb b9 jmp 10e097 /* * Copy a seperator into token. */ if ( i == 0 ) { token[i] = c; 10e0de: 88 03 mov %al,(%ebx) 10e0e0: ba 01 00 00 00 mov $0x1,%edx 10e0e5: b8 01 00 00 00 mov $0x1,%eax /* * Set token_len to the number of characters copied. */ *token_len = i; 10e0ea: 8b 4d 10 mov 0x10(%ebp),%ecx 10e0ed: 89 11 mov %edx,(%ecx) else if ( strcmp( token, "." ) == 0 ) type = IMFS_CURRENT_DIR; } return type; } 10e0ef: 83 c4 08 add $0x8,%esp 10e0f2: 5b pop %ebx 10e0f3: 5e pop %esi 10e0f4: 5f pop %edi 10e0f5: c9 leave 10e0f6: c3 ret /* * Copy a seperator into token. */ if ( i == 0 ) { token[i] = c; 10e0f7: c6 03 00 movb $0x0,(%ebx) 10e0fa: 31 d2 xor %edx,%edx 10e0fc: 31 c0 xor %eax,%eax 10e0fe: eb ea jmp 10e0ea =============================================================================== 0010e100 : 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 ) { 10e100: 55 push %ebp 10e101: 89 e5 mov %esp,%ebp 10e103: 57 push %edi 10e104: 56 push %esi 10e105: 53 push %ebx 10e106: 83 ec 0c sub $0xc,%esp 10e109: 8b 5d 08 mov 0x8(%ebp),%ebx IMFS_jnode_t *jnode; /* * determine/check value for imfs_memfile_bytes_per_block */ IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block, 10e10c: 8b 0d 44 a0 11 00 mov 0x11a044,%ecx * 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) { 10e112: 83 f9 10 cmp $0x10,%ecx 10e115: 74 18 je 10e12f <== NEVER TAKEN 10e117: ba 20 00 00 00 mov $0x20,%edx 10e11c: 31 c0 xor %eax,%eax 10e11e: 39 d1 cmp %edx,%ecx 10e120: 74 0d je 10e12f /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) { 10e122: d1 e2 shl %edx 10e124: 40 inc %eax int bit_mask; /* * check, whether requested bytes per block is valid */ for (bit_mask = 16; !is_valid && (bit_mask <= 512); 10e125: 83 f8 05 cmp $0x5,%eax 10e128: 75 f4 jne 10e11e <== ALWAYS TAKEN 10e12a: 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) 10e12f: 89 0d c8 e3 11 00 mov %ecx,0x11e3c8 * 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( 10e135: 83 ec 0c sub $0xc,%esp 10e138: 6a 00 push $0x0 10e13a: 68 ed 41 00 00 push $0x41ed 10e13f: 68 c6 85 11 00 push $0x1185c6 10e144: 6a 01 push $0x1 10e146: 6a 00 push $0x0 10e148: e8 77 19 00 00 call 10fac4 10e14d: 89 43 18 mov %eax,0x18(%ebx) "", ( S_IFDIR | 0755 ), NULL ); temp_mt_entry->mt_fs_root.handlers = directory_handlers; 10e150: 8b 45 14 mov 0x14(%ebp),%eax 10e153: 89 43 1c mov %eax,0x1c(%ebx) temp_mt_entry->mt_fs_root.ops = op_table; 10e156: 8b 45 0c mov 0xc(%ebp),%eax 10e159: 89 43 20 mov %eax,0x20(%ebx) temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS; 10e15c: 8d 7b 30 lea 0x30(%ebx),%edi 10e15f: be 80 8c 11 00 mov $0x118c80,%esi 10e164: b9 0c 00 00 00 mov $0xc,%ecx 10e169: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create custom file system data. */ fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) ); 10e16b: 83 c4 18 add $0x18,%esp 10e16e: 6a 0c push $0xc 10e170: 6a 01 push $0x1 10e172: e8 45 03 00 00 call 10e4bc if ( !fs_info ){ 10e177: 83 c4 10 add $0x10,%esp 10e17a: 85 c0 test %eax,%eax 10e17c: 74 29 je 10e1a7 <== NEVER TAKEN free(temp_mt_entry->mt_fs_root.node_access); rtems_set_errno_and_return_minus_one(ENOMEM); } temp_mt_entry->fs_info = fs_info; 10e17e: 89 43 2c mov %eax,0x2c(%ebx) /* * Set st_ino for the root to 1. */ fs_info->ino_count = 1; 10e181: c7 00 01 00 00 00 movl $0x1,(%eax) fs_info->memfile_handlers = memfile_handlers; 10e187: 8b 55 10 mov 0x10(%ebp),%edx 10e18a: 89 50 04 mov %edx,0x4(%eax) fs_info->directory_handlers = directory_handlers; 10e18d: 8b 55 14 mov 0x14(%ebp),%edx 10e190: 89 50 08 mov %edx,0x8(%eax) jnode = temp_mt_entry->mt_fs_root.node_access; jnode->st_ino = fs_info->ino_count; 10e193: 8b 43 18 mov 0x18(%ebx),%eax 10e196: c7 40 38 01 00 00 00 movl $0x1,0x38(%eax) 10e19d: 31 c0 xor %eax,%eax return 0; } 10e19f: 8d 65 f4 lea -0xc(%ebp),%esp 10e1a2: 5b pop %ebx 10e1a3: 5e pop %esi 10e1a4: 5f pop %edi 10e1a5: c9 leave 10e1a6: c3 ret /* * 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); 10e1a7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e1aa: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 10e1ad: e8 0e 8f ff ff call 1070c0 <== NOT EXECUTED rtems_set_errno_and_return_minus_one(ENOMEM); 10e1b2: e8 69 20 00 00 call 110220 <__errno> <== NOT EXECUTED 10e1b7: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10e1bd: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e1c2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e1c5: eb d8 jmp 10e19f <== NOT EXECUTED =============================================================================== 0010e1c8 : const char *token, /* IN */ mode_t mode, /* IN */ dev_t dev, /* IN */ rtems_filesystem_location_info_t *pathloc /* IN/OUT */ ) { 10e1c8: 55 push %ebp 10e1c9: 89 e5 mov %esp,%ebp 10e1cb: 57 push %edi 10e1cc: 56 push %esi 10e1cd: 53 push %ebx 10e1ce: 83 ec 50 sub $0x50,%esp 10e1d1: 8b 5d 10 mov 0x10(%ebp),%ebx 10e1d4: 8b 75 14 mov 0x14(%ebp),%esi 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 ); 10e1d7: 8d 45 f0 lea -0x10(%ebp),%eax 10e1da: 50 push %eax 10e1db: 8d 7d bf lea -0x41(%ebp),%edi 10e1de: 57 push %edi 10e1df: ff 75 08 pushl 0x8(%ebp) 10e1e2: e8 45 fe ff ff call 10e02c /* * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) 10e1e7: 8b 45 0c mov 0xc(%ebp),%eax 10e1ea: 25 00 f0 00 00 and $0xf000,%eax 10e1ef: 83 c4 10 add $0x10,%esp 10e1f2: 3d 00 40 00 00 cmp $0x4000,%eax 10e1f7: 74 4f je 10e248 type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) 10e1f9: 3d 00 80 00 00 cmp $0x8000,%eax 10e1fe: 74 40 je 10e240 <== NEVER TAKEN type = IMFS_MEMORY_FILE; else if ( S_ISBLK(mode) || S_ISCHR(mode) ) { 10e200: 3d 00 60 00 00 cmp $0x6000,%eax 10e205: 74 07 je 10e20e <== NEVER TAKEN 10e207: 3d 00 20 00 00 cmp $0x2000,%eax 10e20c: 75 42 jne 10e250 <== NEVER TAKEN type = IMFS_DEVICE; rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor ); 10e20e: 89 5d e0 mov %ebx,-0x20(%ebp) 10e211: 89 75 e4 mov %esi,-0x1c(%ebp) 10e214: ba 02 00 00 00 mov $0x2,%edx /* * Allocate and fill in an IMFS jnode */ new_node = IMFS_create_node( 10e219: 83 ec 0c sub $0xc,%esp 10e21c: 8d 45 e0 lea -0x20(%ebp),%eax 10e21f: 50 push %eax 10e220: ff 75 0c pushl 0xc(%ebp) 10e223: 57 push %edi 10e224: 52 push %edx 10e225: ff 75 18 pushl 0x18(%ebp) 10e228: e8 97 18 00 00 call 10fac4 new_name, mode, &info ); if ( !new_node ) 10e22d: 83 c4 20 add $0x20,%esp 10e230: 85 c0 test %eax,%eax 10e232: 74 2e je 10e262 <== NEVER TAKEN 10e234: 31 c0 xor %eax,%eax rtems_set_errno_and_return_minus_one( ENOMEM ); return 0; } 10e236: 8d 65 f4 lea -0xc(%ebp),%esp 10e239: 5b pop %ebx 10e23a: 5e pop %esi 10e23b: 5f pop %edi 10e23c: c9 leave 10e23d: c3 ret 10e23e: 66 90 xchg %ax,%ax * Figure out what type of IMFS node this is. */ if ( S_ISDIR(mode) ) type = IMFS_DIRECTORY; else if ( S_ISREG(mode) ) 10e240: ba 05 00 00 00 mov $0x5,%edx <== NOT EXECUTED 10e245: eb d2 jmp 10e219 <== NOT EXECUTED 10e247: 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 ); 10e248: ba 01 00 00 00 mov $0x1,%edx 10e24d: eb ca jmp 10e219 10e24f: 90 nop 10e250: e8 cb 1f 00 00 call 110220 <__errno> <== NOT EXECUTED 10e255: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10e25b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e260: eb d4 jmp 10e236 <== NOT EXECUTED mode, &info ); if ( !new_node ) rtems_set_errno_and_return_minus_one( ENOMEM ); 10e262: e8 b9 1f 00 00 call 110220 <__errno> <== NOT EXECUTED 10e267: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10e26d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e272: eb c2 jmp 10e236 <== NOT EXECUTED =============================================================================== 0010e284 : */ int IMFS_rmnod( rtems_filesystem_location_info_t *pathloc /* IN */ ) { 10e284: 55 push %ebp <== NOT EXECUTED 10e285: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e287: 56 push %esi <== NOT EXECUTED 10e288: 53 push %ebx <== NOT EXECUTED 10e289: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10e28c: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED IMFS_jnode_t *the_jnode; the_jnode = (IMFS_jnode_t *) pathloc->node_access; 10e28f: 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 ) { 10e291: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 10e294: 85 c0 test %eax,%eax <== NOT EXECUTED 10e296: 74 13 je 10e2ab <== NOT EXECUTED 10e298: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e29b: 53 push %ebx <== NOT EXECUTED 10e29c: e8 a3 0d 00 00 call 10f044 <_Chain_Extract> <== NOT EXECUTED rtems_chain_extract( (rtems_chain_node *) the_jnode ); the_jnode->Parent = NULL; 10e2a1: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) <== NOT EXECUTED 10e2a8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Decrement the link counter and see if we can free the space. */ the_jnode->st_nlink--; 10e2ab: 66 ff 4b 34 decw 0x34(%ebx) <== NOT EXECUTED IMFS_update_ctime( the_jnode ); 10e2af: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e2b2: 6a 00 push $0x0 <== NOT EXECUTED 10e2b4: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10e2b7: 50 push %eax <== NOT EXECUTED 10e2b8: e8 97 03 00 00 call 10e654 <== NOT EXECUTED 10e2bd: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10e2c0: 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) ) { 10e2c3: 89 1c 24 mov %ebx,(%esp) <== NOT EXECUTED 10e2c6: e8 41 04 00 00 call 10e70c <== NOT EXECUTED 10e2cb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e2ce: 85 c0 test %eax,%eax <== NOT EXECUTED 10e2d0: 75 26 jne 10e2f8 <== NOT EXECUTED 10e2d2: 66 83 7b 34 00 cmpw $0x0,0x34(%ebx) <== NOT EXECUTED 10e2d7: 75 1f jne 10e2f8 <== NOT EXECUTED /* * Is rtems_filesystem_current this node? */ if ( rtems_filesystem_current.node_access == pathloc->node_access ) 10e2d9: 8b 15 b4 c4 11 00 mov 0x11c4b4,%edx <== NOT EXECUTED 10e2df: 8b 42 04 mov 0x4(%edx),%eax <== NOT EXECUTED 10e2e2: 3b 06 cmp (%esi),%eax <== NOT EXECUTED 10e2e4: 74 36 je 10e31c <== NOT EXECUTED /* * Free memory associated with a memory file. */ if ( the_jnode->type == IMFS_SYM_LINK ) { 10e2e6: 83 7b 4c 04 cmpl $0x4,0x4c(%ebx) <== NOT EXECUTED 10e2ea: 74 18 je 10e304 <== NOT EXECUTED if ( the_jnode->info.sym_link.name ) free( (void*) the_jnode->info.sym_link.name ); } free( the_jnode ); 10e2ec: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e2ef: 53 push %ebx <== NOT EXECUTED 10e2f0: e8 cb 8d ff ff call 1070c0 <== NOT EXECUTED 10e2f5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 10e2f8: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e2fa: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10e2fd: 5b pop %ebx <== NOT EXECUTED 10e2fe: 5e pop %esi <== NOT EXECUTED 10e2ff: c9 leave <== NOT EXECUTED 10e300: c3 ret <== NOT EXECUTED 10e301: 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 ) 10e304: 8b 43 50 mov 0x50(%ebx),%eax <== NOT EXECUTED 10e307: 85 c0 test %eax,%eax <== NOT EXECUTED 10e309: 74 e1 je 10e2ec <== NOT EXECUTED free( (void*) the_jnode->info.sym_link.name ); 10e30b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e30e: 50 push %eax <== NOT EXECUTED 10e30f: e8 ac 8d ff ff call 1070c0 <== NOT EXECUTED 10e314: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e317: eb d3 jmp 10e2ec <== NOT EXECUTED 10e319: 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; 10e31c: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 10e323: eb c1 jmp 10e2e6 <== NOT EXECUTED =============================================================================== 0010e328 : int IMFS_stat( rtems_filesystem_location_info_t *loc, struct stat *buf ) { 10e328: 55 push %ebp 10e329: 89 e5 mov %esp,%ebp 10e32b: 53 push %ebx 10e32c: 83 ec 04 sub $0x4,%esp 10e32f: 8b 5d 0c mov 0xc(%ebp),%ebx IMFS_jnode_t *the_jnode; IMFS_device_t *io; the_jnode = loc->node_access; 10e332: 8b 45 08 mov 0x8(%ebp),%eax 10e335: 8b 08 mov (%eax),%ecx switch ( the_jnode->type ) { 10e337: 8b 41 4c mov 0x4c(%ecx),%eax 10e33a: 83 f8 04 cmp $0x4,%eax 10e33d: 74 6d je 10e3ac <== NEVER TAKEN 10e33f: 7f 1b jg 10e35c <== NEVER TAKEN 10e341: 83 f8 02 cmp $0x2,%eax 10e344: 74 72 je 10e3b8 <== ALWAYS TAKEN case IMFS_SYM_LINK: buf->st_size = 0; break; default: rtems_set_errno_and_return_minus_one( ENOTSUP ); 10e346: e8 d5 1e 00 00 call 110220 <__errno> <== NOT EXECUTED 10e34b: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10e351: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED buf->st_ctime = the_jnode->stat_ctime; buf->st_blksize = imfs_rq_memfile_bytes_per_block; return 0; } 10e356: 5a pop %edx <== NOT EXECUTED 10e357: 5b pop %ebx <== NOT EXECUTED 10e358: c9 leave <== NOT EXECUTED 10e359: c3 ret <== NOT EXECUTED 10e35a: 66 90 xchg %ax,%ax <== NOT EXECUTED IMFS_device_t *io; the_jnode = loc->node_access; switch ( the_jnode->type ) { 10e35c: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 10e35f: 7f e5 jg 10e346 <== 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; 10e361: 8b 41 50 mov 0x50(%ecx),%eax <== NOT EXECUTED 10e364: 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; 10e367: 8b 41 30 mov 0x30(%ecx),%eax 10e36a: 89 43 0c mov %eax,0xc(%ebx) buf->st_nlink = the_jnode->st_nlink; 10e36d: 8b 41 34 mov 0x34(%ecx),%eax 10e370: 66 89 43 10 mov %ax,0x10(%ebx) buf->st_ino = the_jnode->st_ino; 10e374: 8b 41 38 mov 0x38(%ecx),%eax 10e377: 89 43 08 mov %eax,0x8(%ebx) buf->st_uid = the_jnode->st_uid; 10e37a: 8b 41 3c mov 0x3c(%ecx),%eax 10e37d: 66 89 43 12 mov %ax,0x12(%ebx) buf->st_gid = the_jnode->st_gid; 10e381: 66 8b 41 3e mov 0x3e(%ecx),%ax 10e385: 66 89 43 14 mov %ax,0x14(%ebx) buf->st_atime = the_jnode->stat_atime; 10e389: 8b 41 40 mov 0x40(%ecx),%eax 10e38c: 89 43 24 mov %eax,0x24(%ebx) buf->st_mtime = the_jnode->stat_mtime; 10e38f: 8b 41 44 mov 0x44(%ecx),%eax 10e392: 89 43 2c mov %eax,0x2c(%ebx) buf->st_ctime = the_jnode->stat_ctime; 10e395: 8b 41 48 mov 0x48(%ecx),%eax 10e398: 89 43 34 mov %eax,0x34(%ebx) buf->st_blksize = imfs_rq_memfile_bytes_per_block; 10e39b: a1 44 a0 11 00 mov 0x11a044,%eax 10e3a0: 89 43 3c mov %eax,0x3c(%ebx) 10e3a3: 31 c0 xor %eax,%eax return 0; } 10e3a5: 5a pop %edx 10e3a6: 5b pop %ebx 10e3a7: c9 leave 10e3a8: c3 ret 10e3a9: 8d 76 00 lea 0x0(%esi),%esi case IMFS_MEMORY_FILE: buf->st_size = the_jnode->info.file.size; break; case IMFS_SYM_LINK: buf->st_size = 0; 10e3ac: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED 10e3b3: eb b2 jmp 10e367 <== NOT EXECUTED 10e3b5: 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 ); 10e3b8: 8b 51 54 mov 0x54(%ecx),%edx 10e3bb: 8b 41 50 mov 0x50(%ecx),%eax 10e3be: 89 03 mov %eax,(%ebx) 10e3c0: 89 53 04 mov %edx,0x4(%ebx) 10e3c3: eb a2 jmp 10e367 =============================================================================== 0010725c : void RTEMS_Malloc_Initialize( void *start, size_t length, size_t sbrk_amount ) { 10725c: 55 push %ebp 10725d: 89 e5 mov %esp,%ebp 10725f: 57 push %edi 107260: 53 push %ebx 107261: 8b 5d 0c mov 0xc(%ebp),%ebx #endif /* * If configured, initialize the statistics support */ if ( rtems_malloc_statistics_helpers ) 107264: a1 e4 c9 11 00 mov 0x11c9e4,%eax 107269: 85 c0 test %eax,%eax 10726b: 74 02 je 10726f <== ALWAYS TAKEN (*rtems_malloc_statistics_helpers->initialize)(); 10726d: ff 10 call *(%eax) <== NOT EXECUTED /* * Initialize the garbage collection list to start with nothing on it. */ malloc_deferred_frees_initialize(); 10726f: e8 80 ff ff ff call 1071f4 starting_address = start; /* * Initialize the optional sbrk support for extending the heap */ if (rtems_malloc_sbrk_helpers) { 107274: a1 e8 c9 11 00 mov 0x11c9e8,%eax 107279: 85 c0 test %eax,%eax 10727b: 74 4b je 1072c8 <== ALWAYS TAKEN starting_address = (*rtems_malloc_sbrk_helpers->initialize)( 10727d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107280: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 107283: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107286: ff 10 call *(%eax) <== NOT EXECUTED 107288: 89 c2 mov %eax,%edx <== NOT EXECUTED 10728a: 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() ) 10728d: a1 f4 e6 11 00 mov 0x11e6f4,%eax 107292: 80 78 28 00 cmpb $0x0,0x28(%eax) 107296: 75 24 jne 1072bc <== NEVER TAKEN void *starting_address, size_t size, uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); 107298: 6a 04 push $0x4 10729a: 53 push %ebx 10729b: 52 push %edx 10729c: 68 00 e5 11 00 push $0x11e500 1072a1: e8 92 40 00 00 call 10b338 <_Heap_Initialize> &RTEMS_Malloc_Heap, starting_address, length, CPU_HEAP_ALIGNMENT ); if ( !status ) 1072a6: 83 c4 10 add $0x10,%esp 1072a9: 85 c0 test %eax,%eax 1072ab: 74 20 je 1072cd <== NEVER TAKEN rtems_print_buffer( (start + length) - 48, 48 ); rtems_fatal_error_occurred( RTEMS_NO_MEMORY ); } #endif MSBUMP(space_available, length); 1072ad: 01 1d 60 e5 11 00 add %ebx,0x11e560 } 1072b3: 8d 65 f8 lea -0x8(%ebp),%esp 1072b6: 5b pop %ebx 1072b7: 5f pop %edi 1072b8: c9 leave 1072b9: c3 ret 1072ba: 66 90 xchg %ax,%ax * 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 ); 1072bc: 31 c0 xor %eax,%eax 1072be: 89 d7 mov %edx,%edi <== NOT EXECUTED 1072c0: 89 d9 mov %ebx,%ecx <== NOT EXECUTED 1072c2: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 1072c4: eb d2 jmp 107298 <== NOT EXECUTED 1072c6: 66 90 xchg %ax,%ax <== NOT EXECUTED starting_address = start; /* * Initialize the optional sbrk support for extending the heap */ if (rtems_malloc_sbrk_helpers) { 1072c8: 8b 55 08 mov 0x8(%ebp),%edx 1072cb: eb c0 jmp 10728d starting_address, length, CPU_HEAP_ALIGNMENT ); if ( !status ) rtems_fatal_error_occurred( status ); 1072cd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1072d0: 6a 00 push $0x0 <== NOT EXECUTED 1072d2: e8 ad 37 00 00 call 10aa84 <== NOT EXECUTED =============================================================================== 0010737c : static rtems_printk_plugin_t print_handler; void Stack_check_Dump_threads_usage( Thread_Control *the_thread ) { 10737c: 55 push %ebp <== NOT EXECUTED 10737d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10737f: 57 push %edi <== NOT EXECUTED 107380: 56 push %esi <== NOT EXECUTED 107381: 53 push %ebx <== NOT EXECUTED 107382: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 107385: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED void *high_water_mark; void *current; Stack_Control *stack; char name[5]; if ( !the_thread ) 107388: 85 db test %ebx,%ebx <== NOT EXECUTED 10738a: 0f 84 c0 00 00 00 je 107450 <== NOT EXECUTED return; if ( !print_handler ) 107390: a1 18 13 12 00 mov 0x121318,%eax <== NOT EXECUTED 107395: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED 107398: 85 c0 test %eax,%eax <== NOT EXECUTED 10739a: 0f 84 b0 00 00 00 je 107450 <== NOT EXECUTED /* * Obtain interrupt stack information */ if (the_thread == (Thread_Control *) -1) { 1073a0: 83 fb ff cmp $0xffffffff,%ebx <== NOT EXECUTED 1073a3: 0f 84 cf 00 00 00 je 107478 <== NOT EXECUTED current = 0; } else return; } else { stack = &the_thread->Start.Initial_stack; 1073a9: 8d bb c4 00 00 00 lea 0xc4(%ebx),%edi <== NOT EXECUTED current = (void *)_CPU_Context_Get_SP( &the_thread->Registers ); 1073af: 8b 83 d8 00 00 00 mov 0xd8(%ebx),%eax <== NOT EXECUTED 1073b5: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED } low = Stack_check_usable_stack_start(stack); 1073b8: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 1073bb: 8d 70 10 lea 0x10(%eax),%esi <== NOT EXECUTED size = Stack_check_usable_stack_size(stack); 1073be: 8b 07 mov (%edi),%eax <== NOT EXECUTED 1073c0: 83 e8 10 sub $0x10,%eax <== NOT EXECUTED 1073c3: 89 45 dc mov %eax,-0x24(%ebp) <== NOT EXECUTED high_water_mark = Stack_check_find_high_water_mark(low, size); 1073c6: 50 push %eax <== NOT EXECUTED 1073c7: 56 push %esi <== NOT EXECUTED 1073c8: e8 73 ff ff ff call 107340 <== NOT EXECUTED if ( high_water_mark ) 1073cd: 5a pop %edx <== NOT EXECUTED 1073ce: 59 pop %ecx <== NOT EXECUTED 1073cf: 85 c0 test %eax,%eax <== NOT EXECUTED 1073d1: 0f 84 dd 00 00 00 je 1074b4 <== NOT EXECUTED used = Stack_check_Calculate_used( low, size, high_water_mark ); 1073d7: 03 75 dc add -0x24(%ebp),%esi <== NOT EXECUTED 1073da: 29 c6 sub %eax,%esi <== NOT EXECUTED else used = 0; if ( the_thread ) { 1073dc: 85 db test %ebx,%ebx <== NOT EXECUTED 1073de: 0f 84 b4 00 00 00 je 107498 <== NOT EXECUTED (*print_handler)( 1073e4: 50 push %eax <== NOT EXECUTED 1073e5: 8d 45 ef lea -0x11(%ebp),%eax <== NOT EXECUTED 1073e8: 50 push %eax <== NOT EXECUTED 1073e9: 6a 05 push $0x5 <== NOT EXECUTED 1073eb: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 1073ee: e8 59 3b 00 00 call 10af4c <== NOT EXECUTED 1073f3: 50 push %eax <== NOT EXECUTED 1073f4: ff 73 08 pushl 0x8(%ebx) <== NOT EXECUTED 1073f7: 68 d7 a9 11 00 push $0x11a9d7 <== NOT EXECUTED 1073fc: ff 35 14 13 12 00 pushl 0x121314 <== NOT EXECUTED 107402: ff 55 d8 call *-0x28(%ebp) <== NOT EXECUTED 107405: 83 c4 20 add $0x20,%esp <== NOT EXECUTED ); } else { (*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 ); } (*print_handler)( 107408: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 10740b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10740e: ff 75 dc pushl -0x24(%ebp) <== NOT EXECUTED 107411: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 107414: 8b 17 mov (%edi),%edx <== NOT EXECUTED 107416: 8d 54 10 ff lea -0x1(%eax,%edx,1),%edx <== NOT EXECUTED 10741a: 52 push %edx <== NOT EXECUTED 10741b: 50 push %eax <== NOT EXECUTED 10741c: 68 f2 a9 11 00 push $0x11a9f2 <== NOT EXECUTED 107421: ff 35 14 13 12 00 pushl 0x121314 <== NOT EXECUTED 107427: ff 15 18 13 12 00 call *0x121318 <== NOT EXECUTED stack->area + stack->size - 1, current, size ); if (Stack_check_Initialized == 0) { 10742d: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 107430: 8b 1d 10 13 12 00 mov 0x121310,%ebx <== NOT EXECUTED 107436: 85 db test %ebx,%ebx <== NOT EXECUTED 107438: 74 1e je 107458 <== NOT EXECUTED (*print_handler)( print_context, "Unavailable\n" ); } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); 10743a: 51 push %ecx <== NOT EXECUTED 10743b: 56 push %esi <== NOT EXECUTED 10743c: 68 1d aa 11 00 push $0x11aa1d <== NOT EXECUTED 107441: ff 35 14 13 12 00 pushl 0x121314 <== NOT EXECUTED 107447: ff 15 18 13 12 00 call *0x121318 <== NOT EXECUTED 10744d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } 107450: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107453: 5b pop %ebx <== NOT EXECUTED 107454: 5e pop %esi <== NOT EXECUTED 107455: 5f pop %edi <== NOT EXECUTED 107456: c9 leave <== NOT EXECUTED 107457: c3 ret <== NOT EXECUTED current, size ); if (Stack_check_Initialized == 0) { (*print_handler)( print_context, "Unavailable\n" ); 107458: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10745b: 68 10 aa 11 00 push $0x11aa10 <== NOT EXECUTED 107460: ff 35 14 13 12 00 pushl 0x121314 <== NOT EXECUTED 107466: ff 15 18 13 12 00 call *0x121318 <== NOT EXECUTED 10746c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { (*print_handler)( print_context, "%8" PRId32 "\n", used ); } } 10746f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107472: 5b pop %ebx <== NOT EXECUTED 107473: 5e pop %esi <== NOT EXECUTED 107474: 5f pop %edi <== NOT EXECUTED 107475: c9 leave <== NOT EXECUTED 107476: c3 ret <== NOT EXECUTED 107477: 90 nop <== NOT EXECUTED /* * Obtain interrupt stack information */ if (the_thread == (Thread_Control *) -1) { if (Stack_check_Interrupt_stack.area) { 107478: 8b 1d 64 15 12 00 mov 0x121564,%ebx <== NOT EXECUTED 10747e: 85 db test %ebx,%ebx <== NOT EXECUTED 107480: 74 ce je 107450 <== NOT EXECUTED stack = &Stack_check_Interrupt_stack; the_thread = 0; current = 0; } else return; 107482: 31 db xor %ebx,%ebx <== NOT EXECUTED 107484: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 10748b: bf 60 15 12 00 mov $0x121560,%edi <== NOT EXECUTED 107490: e9 23 ff ff ff jmp 1073b8 <== NOT EXECUTED 107495: 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 ); 107498: 50 push %eax <== NOT EXECUTED 107499: 6a ff push $0xffffffff <== NOT EXECUTED 10749b: 68 e4 a9 11 00 push $0x11a9e4 <== NOT EXECUTED 1074a0: ff 35 14 13 12 00 pushl 0x121314 <== NOT EXECUTED 1074a6: ff 55 d8 call *-0x28(%ebp) <== NOT EXECUTED 1074a9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1074ac: e9 57 ff ff ff jmp 107408 <== NOT EXECUTED 1074b1: 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 ) 1074b4: 31 f6 xor %esi,%esi <== NOT EXECUTED 1074b6: e9 21 ff ff ff jmp 1073dc <== NOT EXECUTED =============================================================================== 00107690 : /* * Stack_check_Initialize */ void Stack_check_Initialize( void ) { 107690: 55 push %ebp 107691: 89 e5 mov %esp,%ebp 107693: 57 push %edi 107694: 83 ec 04 sub $0x4,%esp uint32_t *p; if (Stack_check_Initialized) 107697: a1 10 13 12 00 mov 0x121310,%eax 10769c: 85 c0 test %eax,%eax 10769e: 75 59 jne 1076f9 for ( p = Stack_check_Pattern.pattern; p < &Stack_check_Pattern.pattern[PATTERN_SIZE_WORDS]; p += 4 ) { p[0] = 0xFEEDF00D; /* FEED FOOD to BAD DOG */ 1076a0: c7 05 50 15 12 00 0d movl $0xfeedf00d,0x121550 1076a7: f0 ed fe p[1] = 0x0BAD0D06; 1076aa: c7 05 54 15 12 00 06 movl $0xbad0d06,0x121554 1076b1: 0d ad 0b p[2] = 0xDEADF00D; /* DEAD FOOD GOOD DOG */ 1076b4: c7 05 58 15 12 00 0d movl $0xdeadf00d,0x121558 1076bb: f0 ad de p[3] = 0x600D0D06; 1076be: c7 05 5c 15 12 00 06 movl $0x600d0d06,0x12155c 1076c5: 0d 0d 60 /* * 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) { 1076c8: 8b 3d 08 17 12 00 mov 0x121708,%edi 1076ce: 85 ff test %edi,%edi 1076d0: 74 1d je 1076ef <== NEVER TAKEN 1076d2: a1 c8 16 12 00 mov 0x1216c8,%eax 1076d7: 85 c0 test %eax,%eax 1076d9: 74 14 je 1076ef <== NEVER TAKEN Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low; 1076db: 89 3d 64 15 12 00 mov %edi,0x121564 Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high - 1076e1: 89 c1 mov %eax,%ecx 1076e3: 29 f9 sub %edi,%ecx 1076e5: 89 0d 60 15 12 00 mov %ecx,0x121560 (char *) _CPU_Interrupt_stack_low; Stack_check_Dope_stack(&Stack_check_Interrupt_stack); 1076eb: b0 a5 mov $0xa5,%al 1076ed: f3 aa rep stos %al,%es:(%edi) } #endif Stack_check_Initialized = 1; 1076ef: c7 05 10 13 12 00 01 movl $0x1,0x121310 1076f6: 00 00 00 } 1076f9: 5f pop %edi 1076fa: 5f pop %edi 1076fb: c9 leave 1076fc: c3 ret =============================================================================== 00107340 : */ void *Stack_check_find_high_water_mark( const void *s, size_t n ) { 107340: 55 push %ebp <== NOT EXECUTED 107341: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107343: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 107346: 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; 107349: 8d 51 10 lea 0x10(%ecx),%edx <== NOT EXECUTED for (ebase = base + length; base < ebase; base++) 10734c: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 10734f: 8d 04 02 lea (%edx,%eax,1),%eax <== NOT EXECUTED 107352: 39 c2 cmp %eax,%edx <== NOT EXECUTED 107354: 73 1d jae 107373 <== NOT EXECUTED if (*base != U32_PATTERN) 107356: 81 79 10 a5 a5 a5 a5 cmpl $0xa5a5a5a5,0x10(%ecx) <== NOT EXECUTED 10735d: 74 0d je 10736c <== NOT EXECUTED 10735f: eb 17 jmp 107378 <== NOT EXECUTED 107361: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 107364: 81 3a a5 a5 a5 a5 cmpl $0xa5a5a5a5,(%edx) <== NOT EXECUTED 10736a: 75 0c jne 107378 <== 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++) 10736c: 83 c2 04 add $0x4,%edx <== NOT EXECUTED 10736f: 39 d0 cmp %edx,%eax <== NOT EXECUTED 107371: 77 f1 ja 107364 <== NOT EXECUTED 107373: 31 c0 xor %eax,%eax <== NOT EXECUTED if (*base != U32_PATTERN) return (void *) base; #endif return (void *)0; } 107375: c9 leave <== NOT EXECUTED 107376: c3 ret <== NOT EXECUTED 107377: 90 nop <== NOT EXECUTED */ base += PATTERN_SIZE_WORDS; for (ebase = base + length; base < ebase; base++) if (*base != U32_PATTERN) return (void *) base; 107378: 89 d0 mov %edx,%eax <== NOT EXECUTED #endif return (void *)0; } 10737a: c9 leave <== NOT EXECUTED 10737b: c3 ret <== NOT EXECUTED =============================================================================== 00107538 : */ void Stack_check_report_blown_task( Thread_Control *running, bool pattern_ok ) { 107538: 55 push %ebp <== NOT EXECUTED 107539: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10753b: 56 push %esi <== NOT EXECUTED 10753c: 53 push %ebx <== NOT EXECUTED 10753d: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 107540: 8a 5d 0c mov 0xc(%ebp),%bl <== NOT EXECUTED Stack_Control *stack = &running->Start.Initial_stack; printk( 107543: ff 76 0c pushl 0xc(%esi) <== NOT EXECUTED 107546: ff 76 08 pushl 0x8(%esi) <== NOT EXECUTED 107549: 56 push %esi <== NOT EXECUTED 10754a: 68 88 aa 11 00 push $0x11aa88 <== NOT EXECUTED 10754f: e8 24 15 00 00 call 108a78 <== NOT EXECUTED rtems_configuration_get_user_multiprocessing_table()->node ); } #endif printk( 107554: 8b 96 c8 00 00 00 mov 0xc8(%esi),%edx <== NOT EXECUTED 10755a: 8b 86 c4 00 00 00 mov 0xc4(%esi),%eax <== NOT EXECUTED 107560: 50 push %eax <== NOT EXECUTED 107561: 8d 44 02 ff lea -0x1(%edx,%eax,1),%eax <== NOT EXECUTED 107565: 50 push %eax <== NOT EXECUTED 107566: 52 push %edx <== NOT EXECUTED 107567: 68 c8 aa 11 00 push $0x11aac8 <== NOT EXECUTED 10756c: e8 07 15 00 00 call 108a78 <== NOT EXECUTED stack->area, stack->area + stack->size - 1, stack->size ); if ( !pattern_ok ) { 107571: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 107574: 84 db test %bl,%bl <== NOT EXECUTED 107576: 74 10 je 107588 <== 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 ); 107578: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10757b: 68 81 00 00 00 push $0x81 <== NOT EXECUTED 107580: e8 17 43 00 00 call 10b89c <== NOT EXECUTED 107585: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED stack->area + stack->size - 1, stack->size ); if ( !pattern_ok ) { printk( 107588: 51 push %ecx <== NOT EXECUTED 107589: 6a 10 push $0x10 <== NOT EXECUTED 10758b: 8b 86 c8 00 00 00 mov 0xc8(%esi),%eax <== NOT EXECUTED 107591: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 107594: 50 push %eax <== NOT EXECUTED 107595: 68 f8 aa 11 00 push $0x11aaf8 <== NOT EXECUTED 10759a: e8 d9 14 00 00 call 108a78 <== NOT EXECUTED 10759f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1075a2: eb d4 jmp 107578 <== NOT EXECUTED =============================================================================== 0010ac28 <_API_extensions_Run_postdriver>: * * _API_extensions_Run_postdriver */ void _API_extensions_Run_postdriver( void ) { 10ac28: 55 push %ebp 10ac29: 89 e5 mov %esp,%ebp 10ac2b: 53 push %ebx 10ac2c: 83 ec 04 sub $0x4,%esp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10ac2f: 8b 1d b8 e8 11 00 mov 0x11e8b8,%ebx !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10ac35: 81 fb bc e8 11 00 cmp $0x11e8bc,%ebx 10ac3b: 74 16 je 10ac53 <_API_extensions_Run_postdriver+0x2b><== NEVER TAKEN 10ac3d: 8d 76 00 lea 0x0(%esi),%esi the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) 10ac40: 8b 43 0c mov 0xc(%ebx),%eax 10ac43: 85 c0 test %eax,%eax 10ac45: 74 02 je 10ac49 <_API_extensions_Run_postdriver+0x21><== NEVER TAKEN (*the_extension->postdriver_hook)(); 10ac47: ff d0 call *%eax 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 ) { 10ac49: 8b 1b mov (%ebx),%ebx { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10ac4b: 81 fb bc e8 11 00 cmp $0x11e8bc,%ebx 10ac51: 75 ed jne 10ac40 <_API_extensions_Run_postdriver+0x18><== NEVER TAKEN the_extension = (API_extensions_Control *) the_node; if ( the_extension->postdriver_hook ) (*the_extension->postdriver_hook)(); } } 10ac53: 5a pop %edx 10ac54: 5b pop %ebx 10ac55: c9 leave 10ac56: c3 ret =============================================================================== 0010ac58 <_API_extensions_Run_postswitch>: * * _API_extensions_Run_postswitch */ void _API_extensions_Run_postswitch( void ) { 10ac58: 55 push %ebp 10ac59: 89 e5 mov %esp,%ebp 10ac5b: 53 push %ebx 10ac5c: 83 ec 04 sub $0x4,%esp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10ac5f: 8b 1d b8 e8 11 00 mov 0x11e8b8,%ebx !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10ac65: 81 fb bc e8 11 00 cmp $0x11e8bc,%ebx 10ac6b: 74 22 je 10ac8f <_API_extensions_Run_postswitch+0x37><== NEVER TAKEN 10ac6d: 8d 76 00 lea 0x0(%esi),%esi the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) 10ac70: 8b 43 10 mov 0x10(%ebx),%eax 10ac73: 85 c0 test %eax,%eax 10ac75: 74 0e je 10ac85 <_API_extensions_Run_postswitch+0x2d><== NEVER TAKEN (*the_extension->postswitch_hook)( _Thread_Executing ); 10ac77: 83 ec 0c sub $0xc,%esp 10ac7a: ff 35 1c e7 11 00 pushl 0x11e71c 10ac80: ff d0 call *%eax 10ac82: 83 c4 10 add $0x10,%esp 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 ) { 10ac85: 8b 1b mov (%ebx),%ebx { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10ac87: 81 fb bc e8 11 00 cmp $0x11e8bc,%ebx 10ac8d: 75 e1 jne 10ac70 <_API_extensions_Run_postswitch+0x18><== NEVER TAKEN the_extension = (API_extensions_Control *) the_node; if ( the_extension->postswitch_hook ) (*the_extension->postswitch_hook)( _Thread_Executing ); } } 10ac8f: 8b 5d fc mov -0x4(%ebp),%ebx 10ac92: c9 leave 10ac93: c3 ret =============================================================================== 0010abf8 <_API_extensions_Run_predriver>: * * _API_extensions_Run_predriver */ void _API_extensions_Run_predriver( void ) { 10abf8: 55 push %ebp 10abf9: 89 e5 mov %esp,%ebp 10abfb: 53 push %ebx 10abfc: 83 ec 04 sub $0x4,%esp Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; 10abff: 8b 1d b8 e8 11 00 mov 0x11e8b8,%ebx !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10ac05: 81 fb bc e8 11 00 cmp $0x11e8bc,%ebx 10ac0b: 74 16 je 10ac23 <_API_extensions_Run_predriver+0x2b><== NEVER TAKEN 10ac0d: 8d 76 00 lea 0x0(%esi),%esi the_node = the_node->next ) { the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) 10ac10: 8b 43 08 mov 0x8(%ebx),%eax 10ac13: 85 c0 test %eax,%eax 10ac15: 74 02 je 10ac19 <_API_extensions_Run_predriver+0x21><== ALWAYS TAKEN (*the_extension->predriver_hook)(); 10ac17: 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 ) { 10ac19: 8b 1b mov (%ebx),%ebx { Chain_Node *the_node; API_extensions_Control *the_extension; for ( the_node = _API_extensions_List.first ; !_Chain_Is_tail( &_API_extensions_List, the_node ) ; 10ac1b: 81 fb bc e8 11 00 cmp $0x11e8bc,%ebx 10ac21: 75 ed jne 10ac10 <_API_extensions_Run_predriver+0x18><== NEVER TAKEN the_extension = (API_extensions_Control *) the_node; if ( the_extension->predriver_hook ) (*the_extension->predriver_hook)(); } } 10ac23: 58 pop %eax 10ac24: 5b pop %ebx 10ac25: c9 leave 10ac26: c3 ret =============================================================================== 0010bcc4 <_CORE_barrier_Wait>: Objects_Id id, bool wait, Watchdog_Interval timeout, CORE_barrier_API_mp_support_callout api_barrier_mp_support ) { 10bcc4: 55 push %ebp 10bcc5: 89 e5 mov %esp,%ebp 10bcc7: 57 push %edi 10bcc8: 56 push %esi 10bcc9: 53 push %ebx 10bcca: 83 ec 04 sub $0x4,%esp 10bccd: 8b 55 08 mov 0x8(%ebp),%edx 10bcd0: 8b 7d 0c mov 0xc(%ebp),%edi 10bcd3: 8b 75 14 mov 0x14(%ebp),%esi 10bcd6: 8b 45 18 mov 0x18(%ebp),%eax 10bcd9: 89 45 f0 mov %eax,-0x10(%ebp) Thread_Control *executing; ISR_Level level; executing = _Thread_Executing; 10bcdc: 8b 0d bc 17 12 00 mov 0x1217bc,%ecx executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL; 10bce2: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) _ISR_Disable( level ); 10bce9: 9c pushf 10bcea: fa cli 10bceb: 5b pop %ebx the_barrier->number_of_waiting_threads++; 10bcec: 8b 42 48 mov 0x48(%edx),%eax 10bcef: 40 inc %eax 10bcf0: 89 42 48 mov %eax,0x48(%edx) if ( the_barrier->number_of_waiting_threads == 10bcf3: 3b 42 44 cmp 0x44(%edx),%eax 10bcf6: 75 07 jne 10bcff <_CORE_barrier_Wait+0x3b> the_barrier->Attributes.maximum_count) { if ( _CORE_barrier_Is_automatic( &the_barrier->Attributes ) ) { 10bcf8: 8b 42 40 mov 0x40(%edx),%eax 10bcfb: 85 c0 test %eax,%eax 10bcfd: 74 29 je 10bd28 <_CORE_barrier_Wait+0x64><== ALWAYS TAKEN { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10bcff: c7 42 30 01 00 00 00 movl $0x1,0x30(%edx) return; } } _Thread_queue_Enter_critical_section( &the_barrier->Wait_queue ); executing->Wait.queue = &the_barrier->Wait_queue; 10bd06: 89 51 44 mov %edx,0x44(%ecx) executing->Wait.id = id; 10bd09: 89 79 20 mov %edi,0x20(%ecx) _ISR_Enable( level ); 10bd0c: 53 push %ebx 10bd0d: 9d popf _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); 10bd0e: c7 45 10 7c da 10 00 movl $0x10da7c,0x10(%ebp) 10bd15: 89 75 0c mov %esi,0xc(%ebp) 10bd18: 89 55 08 mov %edx,0x8(%ebp) } 10bd1b: 58 pop %eax 10bd1c: 5b pop %ebx 10bd1d: 5e pop %esi 10bd1e: 5f pop %edi 10bd1f: c9 leave _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 ); 10bd20: e9 07 1a 00 00 jmp 10d72c <_Thread_queue_Enqueue_with_handler> 10bd25: 8d 76 00 lea 0x0(%esi),%esi _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; 10bd28: c7 41 34 01 00 00 00 movl $0x1,0x34(%ecx) _ISR_Enable( level ); 10bd2f: 53 push %ebx 10bd30: 9d popf _CORE_barrier_Release( the_barrier, id, api_barrier_mp_support ); 10bd31: 8b 45 f0 mov -0x10(%ebp),%eax 10bd34: 89 45 10 mov %eax,0x10(%ebp) 10bd37: 89 7d 0c mov %edi,0xc(%ebp) 10bd3a: 89 55 08 mov %edx,0x8(%ebp) executing->Wait.queue = &the_barrier->Wait_queue; executing->Wait.id = id; _ISR_Enable( level ); _Thread_queue_Enqueue( &the_barrier->Wait_queue, timeout ); } 10bd3d: 5a pop %edx 10bd3e: 5b pop %ebx 10bd3f: 5e pop %esi 10bd40: 5f pop %edi 10bd41: c9 leave 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 ); 10bd42: e9 4d ff ff ff jmp 10bc94 <_CORE_barrier_Release> =============================================================================== 0011553c <_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 ) { 11553c: 55 push %ebp 11553d: 89 e5 mov %esp,%ebp 11553f: 57 push %edi 115540: 56 push %esi 115541: 53 push %ebx 115542: 83 ec 0c sub $0xc,%esp Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 115545: 8b 55 10 mov 0x10(%ebp),%edx 115548: 8b 45 08 mov 0x8(%ebp),%eax 11554b: 39 50 4c cmp %edx,0x4c(%eax) 11554e: 72 58 jb 1155a8 <_CORE_message_queue_Broadcast+0x6c><== NEVER TAKEN * 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 ) { 115550: 8b 75 08 mov 0x8(%ebp),%esi 115553: 8b 46 48 mov 0x48(%esi),%eax 115556: 85 c0 test %eax,%eax 115558: 75 3a jne 115594 <_CORE_message_queue_Broadcast+0x58><== NEVER TAKEN * 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))) { 11555a: 31 db xor %ebx,%ebx 11555c: eb 16 jmp 115574 <_CORE_message_queue_Broadcast+0x38> 11555e: 66 90 xchg %ax,%ax waitp = &the_thread->Wait; number_broadcasted += 1; 115560: 43 inc %ebx * 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 115561: 8b 78 2c mov 0x2c(%eax),%edi 115564: 8b 75 0c mov 0xc(%ebp),%esi 115567: 8b 4d 10 mov 0x10(%ebp),%ecx 11556a: f3 a4 rep movsb %ds:(%esi),%es:(%edi) buffer, waitp->return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 11556c: 8b 40 28 mov 0x28(%eax),%eax 11556f: 8b 55 10 mov 0x10(%ebp),%edx 115572: 89 10 mov %edx,(%eax) * 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))) { 115574: 83 ec 0c sub $0xc,%esp 115577: ff 75 08 pushl 0x8(%ebp) 11557a: e8 29 22 00 00 call 1177a8 <_Thread_queue_Dequeue> 11557f: 83 c4 10 add $0x10,%esp 115582: 85 c0 test %eax,%eax 115584: 75 da jne 115560 <_CORE_message_queue_Broadcast+0x24> if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_message_queue_mp_support) ( the_thread, id ); #endif } *count = number_broadcasted; 115586: 8b 75 1c mov 0x1c(%ebp),%esi 115589: 89 1e mov %ebx,(%esi) return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 11558b: 8d 65 f4 lea -0xc(%ebp),%esp 11558e: 5b pop %ebx 11558f: 5e pop %esi 115590: 5f pop %edi 115591: c9 leave 115592: c3 ret 115593: 90 nop * 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; 115594: 8b 45 1c mov 0x1c(%ebp),%eax <== NOT EXECUTED 115597: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 11559d: 31 c0 xor %eax,%eax <== NOT EXECUTED #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 11559f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1155a2: 5b pop %ebx <== NOT EXECUTED 1155a3: 5e pop %esi <== NOT EXECUTED 1155a4: 5f pop %edi <== NOT EXECUTED 1155a5: c9 leave <== NOT EXECUTED 1155a6: c3 ret <== NOT EXECUTED 1155a7: 90 nop <== NOT EXECUTED { Thread_Control *the_thread; uint32_t number_broadcasted; Thread_Wait_information *waitp; if ( size > the_message_queue->maximum_message_size ) { 1155a8: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED #endif } *count = number_broadcasted; return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; } 1155ad: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1155b0: 5b pop %ebx <== NOT EXECUTED 1155b1: 5e pop %esi <== NOT EXECUTED 1155b2: 5f pop %edi <== NOT EXECUTED 1155b3: c9 leave <== NOT EXECUTED 1155b4: c3 ret <== NOT EXECUTED =============================================================================== 001155f4 <_CORE_message_queue_Flush>: */ uint32_t _CORE_message_queue_Flush( CORE_message_queue_Control *the_message_queue ) { 1155f4: 55 push %ebp 1155f5: 89 e5 mov %esp,%ebp 1155f7: 8b 45 08 mov 0x8(%ebp),%eax if ( the_message_queue->number_of_pending_messages != 0 ) 1155fa: 8b 50 48 mov 0x48(%eax),%edx 1155fd: 85 d2 test %edx,%edx 1155ff: 75 07 jne 115608 <_CORE_message_queue_Flush+0x14> return _CORE_message_queue_Flush_support( the_message_queue ); else return 0; } 115601: 31 c0 xor %eax,%eax 115603: c9 leave 115604: c3 ret 115605: 8d 76 00 lea 0x0(%esi),%esi 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 ); 115608: 89 45 08 mov %eax,0x8(%ebp) else return 0; } 11560b: c9 leave 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 ); 11560c: e9 03 00 00 00 jmp 115614 <_CORE_message_queue_Flush_support> =============================================================================== 0011565c <_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 ) { 11565c: 55 push %ebp 11565d: 89 e5 mov %esp,%ebp 11565f: 57 push %edi 115660: 56 push %esi 115661: 53 push %ebx 115662: 83 ec 0c sub $0xc,%esp 115665: 8b 5d 08 mov 0x8(%ebp),%ebx 115668: 8b 7d 10 mov 0x10(%ebp),%edi 11566b: 8b 55 14 mov 0x14(%ebp),%edx size_t message_buffering_required; size_t allocated_message_size; the_message_queue->maximum_pending_messages = maximum_pending_messages; 11566e: 89 7b 44 mov %edi,0x44(%ebx) the_message_queue->number_of_pending_messages = 0; 115671: c7 43 48 00 00 00 00 movl $0x0,0x48(%ebx) the_message_queue->maximum_message_size = maximum_message_size; 115678: 89 53 4c mov %edx,0x4c(%ebx) 11567b: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) 115682: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) * 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)) { 115689: f6 c2 03 test $0x3,%dl 11568c: 75 1a jne 1156a8 <_CORE_message_queue_Initialize+0x4c> 11568e: 89 d0 mov %edx,%eax /* * 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 * 115690: 8d 70 14 lea 0x14(%eax),%esi 115693: 89 f2 mov %esi,%edx 115695: 0f af d7 imul %edi,%edx (allocated_message_size + sizeof(CORE_message_queue_Buffer_control)); if (message_buffering_required < allocated_message_size) 115698: 39 c2 cmp %eax,%edx 11569a: 73 18 jae 1156b4 <_CORE_message_queue_Initialize+0x58><== ALWAYS TAKEN THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO, STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; 11569c: 31 c0 xor %eax,%eax } 11569e: 8d 65 f4 lea -0xc(%ebp),%esp 1156a1: 5b pop %ebx 1156a2: 5e pop %esi 1156a3: 5f pop %edi 1156a4: c9 leave 1156a5: c3 ret 1156a6: 66 90 xchg %ax,%ax * 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); 1156a8: 8d 42 04 lea 0x4(%edx),%eax allocated_message_size &= ~(sizeof(uint32_t) - 1); 1156ab: 83 e0 fc and $0xfffffffc,%eax } if (allocated_message_size < maximum_message_size) 1156ae: 39 c2 cmp %eax,%edx 1156b0: 77 ea ja 11569c <_CORE_message_queue_Initialize+0x40><== NEVER TAKEN 1156b2: eb dc jmp 115690 <_CORE_message_queue_Initialize+0x34> return false; /* * Attempt to allocate the message memory */ the_message_queue->message_buffers = (CORE_message_queue_Buffer *) 1156b4: 83 ec 0c sub $0xc,%esp 1156b7: 52 push %edx 1156b8: e8 53 32 00 00 call 118910 <_Workspace_Allocate> 1156bd: 89 43 5c mov %eax,0x5c(%ebx) _Workspace_Allocate( message_buffering_required ); if (the_message_queue->message_buffers == 0) 1156c0: 83 c4 10 add $0x10,%esp 1156c3: 85 c0 test %eax,%eax 1156c5: 74 d5 je 11569c <_CORE_message_queue_Initialize+0x40> /* * Initialize the pool of inactive messages, pending messages, * and set of waiting threads. */ _Chain_Initialize ( 1156c7: 56 push %esi 1156c8: 57 push %edi 1156c9: 50 push %eax 1156ca: 8d 43 68 lea 0x68(%ebx),%eax 1156cd: 50 push %eax 1156ce: e8 1d fe ff ff call 1154f0 <_Chain_Initialize> 1156d3: 8d 43 54 lea 0x54(%ebx),%eax 1156d6: 89 43 50 mov %eax,0x50(%ebx) 1156d9: c7 43 54 00 00 00 00 movl $0x0,0x54(%ebx) 1156e0: 8d 43 50 lea 0x50(%ebx),%eax 1156e3: 89 43 58 mov %eax,0x58(%ebx) allocated_message_size + sizeof( CORE_message_queue_Buffer_control ) ); _Chain_Initialize_empty( &the_message_queue->Pending_messages ); _Thread_queue_Initialize( 1156e6: 6a 06 push $0x6 1156e8: 68 80 00 00 00 push $0x80 1156ed: 8b 45 0c mov 0xc(%ebp),%eax 1156f0: 83 38 01 cmpl $0x1,(%eax) 1156f3: 0f 94 c0 sete %al 1156f6: 0f b6 c0 movzbl %al,%eax 1156f9: 50 push %eax 1156fa: 53 push %ebx 1156fb: e8 58 24 00 00 call 117b58 <_Thread_queue_Initialize> 115700: b0 01 mov $0x1,%al 115702: 83 c4 20 add $0x20,%esp STATES_WAITING_FOR_MESSAGE, CORE_MESSAGE_QUEUE_STATUS_TIMEOUT ); return true; } 115705: 8d 65 f4 lea -0xc(%ebp),%esp 115708: 5b pop %ebx 115709: 5e pop %esi 11570a: 5f pop %edi 11570b: c9 leave 11570c: c3 ret =============================================================================== 0010f0a8 <_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 ) { 10f0a8: 55 push %ebp 10f0a9: 89 e5 mov %esp,%ebp 10f0ab: 57 push %edi 10f0ac: 56 push %esi 10f0ad: 53 push %ebx 10f0ae: 83 ec 04 sub $0x4,%esp 10f0b1: 8b 75 08 mov 0x8(%ebp),%esi 10f0b4: 8b 7d 0c mov 0xc(%ebp),%edi 10f0b7: 8b 45 10 mov 0x10(%ebp),%eax ISR_Level level; bool notify = false; the_message->priority = submit_type; 10f0ba: 89 47 08 mov %eax,0x8(%edi) switch ( submit_type ) { 10f0bd: 3d 00 00 00 80 cmp $0x80000000,%eax 10f0c2: 0f 84 94 00 00 00 je 10f15c <_CORE_message_queue_Insert_message+0xb4> 10f0c8: 3d ff ff ff 7f cmp $0x7fffffff,%eax 10f0cd: 74 65 je 10f134 <_CORE_message_queue_Insert_message+0x8c><== ALWAYS TAKEN 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; 10f0cf: 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 10f0d2: 8d 56 54 lea 0x54(%esi),%edx <== NOT EXECUTED while ( !_Chain_Is_tail( the_header, the_node ) ) { 10f0d5: 39 da cmp %ebx,%edx <== NOT EXECUTED 10f0d7: 75 49 jne 10f122 <_CORE_message_queue_Insert_message+0x7a><== NOT EXECUTED 10f0d9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 10f0dc: 89 d3 mov %edx,%ebx <== NOT EXECUTED continue; } break; } _ISR_Disable( level ); 10f0de: 9c pushf <== NOT EXECUTED 10f0df: fa cli <== NOT EXECUTED 10f0e0: 59 pop %ecx <== NOT EXECUTED if ( the_message_queue->number_of_pending_messages++ == 0 ) 10f0e1: 8b 56 48 mov 0x48(%esi),%edx <== NOT EXECUTED 10f0e4: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 10f0e7: 89 46 48 mov %eax,0x48(%esi) <== NOT EXECUTED 10f0ea: 85 d2 test %edx,%edx <== NOT EXECUTED 10f0ec: 0f 94 45 f3 sete -0xd(%ebp) <== NOT EXECUTED notify = true; _Chain_Insert_unprotected( the_node->previous, &the_message->Node ); 10f0f0: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 10f0f3: 89 47 04 mov %eax,0x4(%edi) <== NOT EXECUTED 10f0f6: 8b 10 mov (%eax),%edx <== NOT EXECUTED 10f0f8: 89 38 mov %edi,(%eax) <== NOT EXECUTED 10f0fa: 89 17 mov %edx,(%edi) <== NOT EXECUTED 10f0fc: 89 7a 04 mov %edi,0x4(%edx) <== NOT EXECUTED _ISR_Enable( level ); 10f0ff: 51 push %ecx <== NOT EXECUTED 10f100: 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 ) 10f101: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) 10f105: 74 25 je 10f12c <_CORE_message_queue_Insert_message+0x84> 10f107: 8b 4e 60 mov 0x60(%esi),%ecx 10f10a: 85 c9 test %ecx,%ecx 10f10c: 74 1e je 10f12c <_CORE_message_queue_Insert_message+0x84><== ALWAYS TAKEN (*the_message_queue->notify_handler)( the_message_queue->notify_argument ); 10f10e: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED 10f111: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10f114: 5a pop %edx <== NOT EXECUTED 10f115: 5b pop %ebx <== NOT EXECUTED 10f116: 5e pop %esi <== NOT EXECUTED 10f117: 5f pop %edi <== NOT EXECUTED 10f118: c9 leave <== NOT EXECUTED * 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 ); 10f119: ff e1 jmp *%ecx <== NOT EXECUTED 10f11b: 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; 10f11c: 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 ) ) { 10f11e: 39 da cmp %ebx,%edx <== NOT EXECUTED 10f120: 74 ba je 10f0dc <_CORE_message_queue_Insert_message+0x34><== NOT EXECUTED this_message = (CORE_message_queue_Buffer_control *) the_node; if ( this_message->priority <= the_message->priority ) { 10f122: 3b 43 08 cmp 0x8(%ebx),%eax <== NOT EXECUTED 10f125: 7d f5 jge 10f11c <_CORE_message_queue_Insert_message+0x74><== NOT EXECUTED 10f127: eb b5 jmp 10f0de <_CORE_message_queue_Insert_message+0x36><== NOT EXECUTED 10f129: 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 ); } 10f12c: 58 pop %eax 10f12d: 5b pop %ebx 10f12e: 5e pop %esi 10f12f: 5f pop %edi 10f130: c9 leave 10f131: c3 ret 10f132: 66 90 xchg %ax,%ax the_message->priority = submit_type; switch ( submit_type ) { case CORE_MESSAGE_QUEUE_SEND_REQUEST: _ISR_Disable( level ); 10f134: 9c pushf 10f135: fa cli 10f136: 59 pop %ecx if ( the_message_queue->number_of_pending_messages++ == 0 ) 10f137: 8b 56 48 mov 0x48(%esi),%edx 10f13a: 8d 42 01 lea 0x1(%edx),%eax 10f13d: 89 46 48 mov %eax,0x48(%esi) 10f140: 85 d2 test %edx,%edx 10f142: 0f 94 45 f3 sete -0xd(%ebp) 10f146: 8d 46 54 lea 0x54(%esi),%eax 10f149: 89 07 mov %eax,(%edi) 10f14b: 8b 46 58 mov 0x58(%esi),%eax 10f14e: 89 7e 58 mov %edi,0x58(%esi) 10f151: 89 38 mov %edi,(%eax) 10f153: 89 47 04 mov %eax,0x4(%edi) notify = true; _CORE_message_queue_Append_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 10f156: 51 push %ecx 10f157: 9d popf 10f158: eb a7 jmp 10f101 <_CORE_message_queue_Insert_message+0x59> 10f15a: 66 90 xchg %ax,%ax break; case CORE_MESSAGE_QUEUE_URGENT_REQUEST: _ISR_Disable( level ); 10f15c: 9c pushf 10f15d: fa cli 10f15e: 59 pop %ecx if ( the_message_queue->number_of_pending_messages++ == 0 ) 10f15f: 8b 56 48 mov 0x48(%esi),%edx 10f162: 8d 42 01 lea 0x1(%edx),%eax 10f165: 89 46 48 mov %eax,0x48(%esi) 10f168: 85 d2 test %edx,%edx 10f16a: 0f 94 45 f3 sete -0xd(%ebp) 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 10f16e: 8d 46 50 lea 0x50(%esi),%eax 10f171: 89 47 04 mov %eax,0x4(%edi) 10f174: 8b 46 50 mov 0x50(%esi),%eax 10f177: 89 7e 50 mov %edi,0x50(%esi) 10f17a: 89 07 mov %eax,(%edi) 10f17c: 89 78 04 mov %edi,0x4(%eax) notify = true; _CORE_message_queue_Prepend_unprotected(the_message_queue, the_message); _ISR_Enable( level ); 10f17f: 51 push %ecx 10f180: 9d popf 10f181: e9 7b ff ff ff jmp 10f101 <_CORE_message_queue_Insert_message+0x59> =============================================================================== 00115710 <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Watchdog_Interval timeout ) { 115710: 55 push %ebp 115711: 89 e5 mov %esp,%ebp 115713: 57 push %edi 115714: 56 push %esi 115715: 53 push %ebx 115716: 83 ec 1c sub $0x1c,%esp 115719: 8b 45 08 mov 0x8(%ebp),%eax 11571c: 89 45 f0 mov %eax,-0x10(%ebp) 11571f: 8b 7d 0c mov 0xc(%ebp),%edi 115722: 8b 45 10 mov 0x10(%ebp),%eax 115725: 89 45 ec mov %eax,-0x14(%ebp) 115728: 8b 4d 14 mov 0x14(%ebp),%ecx 11572b: 8b 45 1c mov 0x1c(%ebp),%eax 11572e: 89 45 e4 mov %eax,-0x1c(%ebp) 115731: 8a 45 18 mov 0x18(%ebp),%al 115734: 88 45 eb mov %al,-0x15(%ebp) ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *executing; Thread_Control *the_thread; executing = _Thread_Executing; 115737: 8b 15 fc 5a 13 00 mov 0x135afc,%edx executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL; 11573d: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) _ISR_Disable( level ); 115744: 9c pushf 115745: fa cli 115746: 5e pop %esi * 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( 115747: 8b 45 f0 mov -0x10(%ebp),%eax 11574a: 8b 58 50 mov 0x50(%eax),%ebx 11574d: 83 c0 54 add $0x54,%eax 115750: 39 c3 cmp %eax,%ebx 115752: 74 7c je 1157d0 <_CORE_message_queue_Seize+0xc0> 115754: 8b 13 mov (%ebx),%edx 115756: 8b 7d f0 mov -0x10(%ebp),%edi 115759: 89 57 50 mov %edx,0x50(%edi) 11575c: 89 f8 mov %edi,%eax 11575e: 83 c0 50 add $0x50,%eax 115761: 89 42 04 mov %eax,0x4(%edx) the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); if ( the_message != NULL ) { the_message_queue->number_of_pending_messages -= 1; 115764: ff 4f 48 decl 0x48(%edi) _ISR_Enable( level ); 115767: 56 push %esi 115768: 9d popf *size_p = the_message->Contents.size; 115769: 8b 43 0c mov 0xc(%ebx),%eax 11576c: 89 01 mov %eax,(%ecx) _Thread_Executing->Wait.count = the_message->priority; 11576e: 8b 53 08 mov 0x8(%ebx),%edx 115771: a1 fc 5a 13 00 mov 0x135afc,%eax 115776: 89 50 24 mov %edx,0x24(%eax) _CORE_message_queue_Copy_buffer(the_message->Contents.buffer,buffer,*size_p); 115779: 8d 43 10 lea 0x10(%ebx),%eax 11577c: 89 45 d8 mov %eax,-0x28(%ebp) * 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 11577f: 8b 09 mov (%ecx),%ecx 115781: 8b 7d ec mov -0x14(%ebp),%edi 115784: 89 c6 mov %eax,%esi 115786: f3 a4 rep movsb %ds:(%esi),%es:(%edi) * * 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 ); 115788: 83 ec 0c sub $0xc,%esp 11578b: ff 75 f0 pushl -0x10(%ebp) 11578e: e8 15 20 00 00 call 1177a8 <_Thread_queue_Dequeue> 115793: 89 c2 mov %eax,%edx if ( !the_thread ) { 115795: 83 c4 10 add $0x10,%esp 115798: 85 c0 test %eax,%eax 11579a: 0f 84 84 00 00 00 je 115824 <_CORE_message_queue_Seize+0x114><== ALWAYS TAKEN * 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; 1157a0: 8b 40 24 mov 0x24(%eax),%eax <== NOT EXECUTED 1157a3: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED the_message->Contents.size = (size_t) the_thread->Wait.option; 1157a6: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED 1157a9: 89 4b 0c mov %ecx,0xc(%ebx) <== NOT EXECUTED 1157ac: 8b 72 2c mov 0x2c(%edx),%esi <== NOT EXECUTED 1157af: 8b 7d d8 mov -0x28(%ebp),%edi <== NOT EXECUTED 1157b2: 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( 1157b4: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 1157b7: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 1157ba: 89 5d 0c mov %ebx,0xc(%ebp) <== NOT EXECUTED 1157bd: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1157c0: 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 ); } 1157c3: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1157c6: 5b pop %ebx <== NOT EXECUTED 1157c7: 5e pop %esi <== NOT EXECUTED 1157c8: 5f pop %edi <== NOT EXECUTED 1157c9: 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( 1157ca: e9 29 4e 00 00 jmp 11a5f8 <_CORE_message_queue_Insert_message><== NOT EXECUTED 1157cf: 90 nop <== NOT EXECUTED the_message->priority ); return; } if ( !wait ) { 1157d0: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) 1157d4: 75 12 jne 1157e8 <_CORE_message_queue_Seize+0xd8> _ISR_Enable( level ); 1157d6: 56 push %esi 1157d7: 9d popf executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT; 1157d8: c7 42 34 04 00 00 00 movl $0x4,0x34(%edx) 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 ); } 1157df: 8d 65 f4 lea -0xc(%ebp),%esp 1157e2: 5b pop %ebx 1157e3: 5e pop %esi 1157e4: 5f pop %edi 1157e5: c9 leave 1157e6: c3 ret 1157e7: 90 nop { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 1157e8: 8b 45 f0 mov -0x10(%ebp),%eax 1157eb: c7 40 30 01 00 00 00 movl $0x1,0x30(%eax) 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; 1157f2: 89 42 44 mov %eax,0x44(%edx) executing->Wait.id = id; 1157f5: 89 7a 20 mov %edi,0x20(%edx) executing->Wait.return_argument_second.mutable_object = buffer; 1157f8: 8b 7d ec mov -0x14(%ebp),%edi 1157fb: 89 7a 2c mov %edi,0x2c(%edx) executing->Wait.return_argument = size_p; 1157fe: 89 4a 28 mov %ecx,0x28(%edx) /* Wait.count will be filled in with the message priority */ _ISR_Enable( level ); 115801: 56 push %esi 115802: 9d popf _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 115803: c7 45 10 34 7c 11 00 movl $0x117c34,0x10(%ebp) 11580a: 8b 45 e4 mov -0x1c(%ebp),%eax 11580d: 89 45 0c mov %eax,0xc(%ebp) 115810: 8b 7d f0 mov -0x10(%ebp),%edi 115813: 89 7d 08 mov %edi,0x8(%ebp) } 115816: 8d 65 f4 lea -0xc(%ebp),%esp 115819: 5b pop %ebx 11581a: 5e pop %esi 11581b: 5f pop %edi 11581c: c9 leave 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 ); 11581d: e9 c2 20 00 00 jmp 1178e4 <_Thread_queue_Enqueue_with_handler> 115822: 66 90 xchg %ax,%ax * @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 115824: 89 5d 0c mov %ebx,0xc(%ebp) 115827: 8b 45 f0 mov -0x10(%ebp),%eax 11582a: 83 c0 68 add $0x68,%eax 11582d: 89 45 08 mov %eax,0x8(%ebp) } 115830: 8d 65 f4 lea -0xc(%ebp),%esp 115833: 5b pop %ebx 115834: 5e pop %esi 115835: 5f pop %edi 115836: c9 leave 115837: e9 68 fc ff ff jmp 1154a4 <_Chain_Append> =============================================================================== 0010adc8 <_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 ) { 10adc8: 55 push %ebp 10adc9: 89 e5 mov %esp,%ebp 10adcb: 57 push %edi 10adcc: 56 push %esi 10adcd: 53 push %ebx 10adce: 83 ec 1c sub $0x1c,%esp 10add1: 8b 5d 08 mov 0x8(%ebp),%ebx 10add4: 8a 45 20 mov 0x20(%ebp),%al 10add7: 88 45 f3 mov %al,-0xd(%ebp) ISR_Level level; CORE_message_queue_Buffer_control *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 10adda: 8b 55 10 mov 0x10(%ebp),%edx 10addd: 39 53 4c cmp %edx,0x4c(%ebx) 10ade0: 72 6e jb 10ae50 <_CORE_message_queue_Submit+0x88> /* * Is there a thread currently waiting on this message queue? */ if ( the_message_queue->number_of_pending_messages == 0 ) { 10ade2: 8b 43 48 mov 0x48(%ebx),%eax 10ade5: 85 c0 test %eax,%eax 10ade7: 74 77 je 10ae60 <_CORE_message_queue_Submit+0x98> /* * 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 < 10ade9: 39 43 44 cmp %eax,0x44(%ebx) 10adec: 0f 87 be 00 00 00 ja 10aeb0 <_CORE_message_queue_Submit+0xe8> * 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 ) { 10adf2: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) 10adf6: 0f 84 9c 00 00 00 je 10ae98 <_CORE_message_queue_Submit+0xd0><== ALWAYS TAKEN /* * 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() ) { 10adfc: a1 f8 e6 11 00 mov 0x11e6f8,%eax <== NOT EXECUTED 10ae01: 85 c0 test %eax,%eax <== NOT EXECUTED 10ae03: 0f 85 97 00 00 00 jne 10aea0 <_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; 10ae09: a1 1c e7 11 00 mov 0x11e71c,%eax <== NOT EXECUTED _ISR_Disable( level ); 10ae0e: 9c pushf <== NOT EXECUTED 10ae0f: fa cli <== NOT EXECUTED 10ae10: 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 10ae11: 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; 10ae18: 89 58 44 mov %ebx,0x44(%eax) <== NOT EXECUTED executing->Wait.id = id; 10ae1b: 8b 75 14 mov 0x14(%ebp),%esi <== NOT EXECUTED 10ae1e: 89 70 20 mov %esi,0x20(%eax) <== NOT EXECUTED executing->Wait.return_argument_second.immutable_object = buffer; 10ae21: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10ae24: 89 48 2c mov %ecx,0x2c(%eax) <== NOT EXECUTED executing->Wait.option = (uint32_t) size; 10ae27: 8b 75 10 mov 0x10(%ebp),%esi <== NOT EXECUTED 10ae2a: 89 70 30 mov %esi,0x30(%eax) <== NOT EXECUTED executing->Wait.count = submit_type; 10ae2d: 8b 4d 1c mov 0x1c(%ebp),%ecx <== NOT EXECUTED 10ae30: 89 48 24 mov %ecx,0x24(%eax) <== NOT EXECUTED _ISR_Enable( level ); 10ae33: 52 push %edx <== NOT EXECUTED 10ae34: 9d popf <== NOT EXECUTED _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); 10ae35: 50 push %eax <== NOT EXECUTED 10ae36: 68 fc ca 10 00 push $0x10cafc <== NOT EXECUTED 10ae3b: ff 75 24 pushl 0x24(%ebp) <== NOT EXECUTED 10ae3e: 53 push %ebx <== NOT EXECUTED 10ae3f: e8 68 19 00 00 call 10c7ac <_Thread_queue_Enqueue_with_handler><== NOT EXECUTED 10ae44: b8 07 00 00 00 mov $0x7,%eax <== NOT EXECUTED 10ae49: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ae4c: eb 07 jmp 10ae55 <_CORE_message_queue_Submit+0x8d><== NOT EXECUTED 10ae4e: 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 ) { 10ae50: b8 01 00 00 00 mov $0x1,%eax _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; } 10ae55: 8d 65 f4 lea -0xc(%ebp),%esp 10ae58: 5b pop %ebx 10ae59: 5e pop %esi 10ae5a: 5f pop %edi 10ae5b: c9 leave 10ae5c: c3 ret 10ae5d: 8d 76 00 lea 0x0(%esi),%esi /* * 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 ); 10ae60: 83 ec 0c sub $0xc,%esp 10ae63: 53 push %ebx 10ae64: e8 07 18 00 00 call 10c670 <_Thread_queue_Dequeue> 10ae69: 89 c2 mov %eax,%edx if ( the_thread ) { 10ae6b: 83 c4 10 add $0x10,%esp 10ae6e: 85 c0 test %eax,%eax 10ae70: 74 7e je 10aef0 <_CORE_message_queue_Submit+0x128> * 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 10ae72: 8b 78 2c mov 0x2c(%eax),%edi 10ae75: 8b 75 0c mov 0xc(%ebp),%esi 10ae78: 8b 4d 10 mov 0x10(%ebp),%ecx 10ae7b: f3 a4 rep movsb %ds:(%esi),%es:(%edi) _CORE_message_queue_Copy_buffer( buffer, the_thread->Wait.return_argument_second.mutable_object, size ); *(size_t *) the_thread->Wait.return_argument = size; 10ae7d: 8b 40 28 mov 0x28(%eax),%eax 10ae80: 8b 4d 10 mov 0x10(%ebp),%ecx 10ae83: 89 08 mov %ecx,(%eax) the_thread->Wait.count = submit_type; 10ae85: 8b 75 1c mov 0x1c(%ebp),%esi 10ae88: 89 72 24 mov %esi,0x24(%edx) 10ae8b: 31 c0 xor %eax,%eax _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; } 10ae8d: 8d 65 f4 lea -0xc(%ebp),%esp 10ae90: 5b pop %ebx 10ae91: 5e pop %esi 10ae92: 5f pop %edi 10ae93: c9 leave 10ae94: c3 ret 10ae95: 8d 76 00 lea 0x0(%esi),%esi * 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 ) { 10ae98: b8 02 00 00 00 mov $0x2,%eax 10ae9d: eb b6 jmp 10ae55 <_CORE_message_queue_Submit+0x8d> 10ae9f: 90 nop _ISR_Enable( level ); _Thread_queue_Enqueue( &the_message_queue->Wait_queue, timeout ); } return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT; 10aea0: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED } 10aea5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10aea8: 5b pop %ebx <== NOT EXECUTED 10aea9: 5e pop %esi <== NOT EXECUTED 10aeaa: 5f pop %edi <== NOT EXECUTED 10aeab: c9 leave <== NOT EXECUTED 10aeac: c3 ret <== NOT EXECUTED 10aead: 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. 10aeb0: 83 ec 0c sub $0xc,%esp 10aeb3: 8d 43 68 lea 0x68(%ebx),%eax 10aeb6: 50 push %eax 10aeb7: e8 e4 fe ff ff call 10ada0 <_Chain_Get> /* * NOTE: If the system is consistent, this error should never occur. */ if ( !the_message ) { 10aebc: 83 c4 10 add $0x10,%esp 10aebf: 85 c0 test %eax,%eax 10aec1: 74 dd je 10aea0 <_CORE_message_queue_Submit+0xd8><== NEVER TAKEN * 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 10aec3: 8d 78 10 lea 0x10(%eax),%edi 10aec6: 8b 75 0c mov 0xc(%ebp),%esi 10aec9: 8b 4d 10 mov 0x10(%ebp),%ecx 10aecc: f3 a4 rep movsb %ds:(%esi),%es:(%edi) _CORE_message_queue_Copy_buffer( buffer, the_message->Contents.buffer, size ); the_message->Contents.size = size; 10aece: 8b 55 10 mov 0x10(%ebp),%edx 10aed1: 89 50 0c mov %edx,0xc(%eax) the_message->priority = submit_type; 10aed4: 8b 4d 1c mov 0x1c(%ebp),%ecx 10aed7: 89 48 08 mov %ecx,0x8(%eax) _CORE_message_queue_Insert_message( 10aeda: 52 push %edx 10aedb: 51 push %ecx 10aedc: 50 push %eax 10aedd: 53 push %ebx 10aede: e8 c5 41 00 00 call 10f0a8 <_CORE_message_queue_Insert_message> 10aee3: 31 c0 xor %eax,%eax 10aee5: 83 c4 10 add $0x10,%esp 10aee8: e9 68 ff ff ff jmp 10ae55 <_CORE_message_queue_Submit+0x8d> 10aeed: 8d 76 00 lea 0x0(%esi),%esi * 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 ) { 10aef0: 8b 43 48 mov 0x48(%ebx),%eax 10aef3: e9 f1 fe ff ff jmp 10ade9 <_CORE_message_queue_Submit+0x21> =============================================================================== 0010af04 <_CORE_mutex_Initialize>: CORE_mutex_Status _CORE_mutex_Initialize( CORE_mutex_Control *the_mutex, CORE_mutex_Attributes *the_mutex_attributes, uint32_t initial_lock ) { 10af04: 55 push %ebp 10af05: 89 e5 mov %esp,%ebp 10af07: 57 push %edi 10af08: 56 push %esi 10af09: 83 ec 10 sub $0x10,%esp 10af0c: 8b 55 08 mov 0x8(%ebp),%edx 10af0f: 8b 45 10 mov 0x10(%ebp),%eax /* 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; 10af12: 8d 7a 40 lea 0x40(%edx),%edi 10af15: b9 04 00 00 00 mov $0x4,%ecx 10af1a: 8b 75 0c mov 0xc(%ebp),%esi 10af1d: f3 a5 rep movsl %ds:(%esi),%es:(%edi) the_mutex->lock = initial_lock; 10af1f: 89 42 50 mov %eax,0x50(%edx) the_mutex->blocked_count = 0; 10af22: c7 42 58 00 00 00 00 movl $0x0,0x58(%edx) if ( initial_lock == CORE_MUTEX_LOCKED ) { 10af29: 85 c0 test %eax,%eax 10af2b: 75 33 jne 10af60 <_CORE_mutex_Initialize+0x5c> the_mutex->nest_count = 1; 10af2d: c7 42 54 01 00 00 00 movl $0x1,0x54(%edx) the_mutex->holder = _Thread_Executing; 10af34: 8b 0d 1c e7 11 00 mov 0x11e71c,%ecx 10af3a: 89 4a 5c mov %ecx,0x5c(%edx) the_mutex->holder_id = _Thread_Executing->Object.id; 10af3d: 8b 41 08 mov 0x8(%ecx),%eax 10af40: 89 42 60 mov %eax,0x60(%edx) /** * 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 10af43: 8b 42 48 mov 0x48(%edx),%eax if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 10af46: 83 f8 02 cmp $0x2,%eax 10af49: 74 05 je 10af50 <_CORE_mutex_Initialize+0x4c> 10af4b: 83 f8 03 cmp $0x3,%eax 10af4e: 75 25 jne 10af75 <_CORE_mutex_Initialize+0x71><== ALWAYS TAKEN _CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) { if ( _Thread_Executing->current_priority < 10af50: 8b 41 14 mov 0x14(%ecx),%eax 10af53: 3b 42 4c cmp 0x4c(%edx),%eax 10af56: 72 48 jb 10afa0 <_CORE_mutex_Initialize+0x9c><== NEVER TAKEN _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++; 10af58: ff 41 1c incl 0x1c(%ecx) 10af5b: eb 18 jmp 10af75 <_CORE_mutex_Initialize+0x71> 10af5d: 8d 76 00 lea 0x0(%esi),%esi } } else { the_mutex->nest_count = 0; 10af60: c7 42 54 00 00 00 00 movl $0x0,0x54(%edx) the_mutex->holder = NULL; 10af67: c7 42 5c 00 00 00 00 movl $0x0,0x5c(%edx) the_mutex->holder_id = 0; 10af6e: c7 42 60 00 00 00 00 movl $0x0,0x60(%edx) } _Thread_queue_Initialize( 10af75: 6a 05 push $0x5 10af77: 68 00 04 00 00 push $0x400 10af7c: 8b 45 0c mov 0xc(%ebp),%eax 10af7f: 8b 40 08 mov 0x8(%eax),%eax 10af82: 85 c0 test %eax,%eax 10af84: 0f 95 c0 setne %al 10af87: 0f b6 c0 movzbl %al,%eax 10af8a: 50 push %eax 10af8b: 52 push %edx 10af8c: e8 8f 1a 00 00 call 10ca20 <_Thread_queue_Initialize> 10af91: 31 c0 xor %eax,%eax 10af93: 83 c4 10 add $0x10,%esp STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10af96: 8d 65 f8 lea -0x8(%ebp),%esp 10af99: 5e pop %esi 10af9a: 5f pop %edi 10af9b: c9 leave 10af9c: c3 ret 10af9d: 8d 76 00 lea 0x0(%esi),%esi 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 < 10afa0: b8 06 00 00 00 mov $0x6,%eax <== NOT EXECUTED STATES_WAITING_FOR_MUTEX, CORE_MUTEX_TIMEOUT ); return CORE_MUTEX_STATUS_SUCCESSFUL; } 10afa5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10afa8: 5e pop %esi <== NOT EXECUTED 10afa9: 5f pop %edi <== NOT EXECUTED 10afaa: c9 leave <== NOT EXECUTED 10afab: c3 ret <== NOT EXECUTED =============================================================================== 0010affc <_CORE_mutex_Seize>: Objects_Id _id, bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { 10affc: 55 push %ebp 10affd: 89 e5 mov %esp,%ebp 10afff: 56 push %esi 10b000: 53 push %ebx 10b001: 8b 75 08 mov 0x8(%ebp),%esi 10b004: 8a 5d 10 mov 0x10(%ebp),%bl _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10b007: a1 58 e6 11 00 mov 0x11e658,%eax 10b00c: 85 c0 test %eax,%eax 10b00e: 74 04 je 10b014 <_CORE_mutex_Seize+0x18> 10b010: 84 db test %bl,%bl 10b012: 75 30 jne 10b044 <_CORE_mutex_Seize+0x48><== ALWAYS TAKEN 10b014: 83 ec 08 sub $0x8,%esp 10b017: 8d 45 18 lea 0x18(%ebp),%eax 10b01a: 50 push %eax 10b01b: 56 push %esi 10b01c: e8 67 41 00 00 call 10f188 <_CORE_mutex_Seize_interrupt_trylock> 10b021: 83 c4 10 add $0x10,%esp 10b024: 85 c0 test %eax,%eax 10b026: 74 14 je 10b03c <_CORE_mutex_Seize+0x40> 10b028: 84 db test %bl,%bl 10b02a: 75 30 jne 10b05c <_CORE_mutex_Seize+0x60> 10b02c: ff 75 18 pushl 0x18(%ebp) 10b02f: 9d popf 10b030: a1 1c e7 11 00 mov 0x11e71c,%eax 10b035: c7 40 34 01 00 00 00 movl $0x1,0x34(%eax) } 10b03c: 8d 65 f8 lea -0x8(%ebp),%esp 10b03f: 5b pop %ebx 10b040: 5e pop %esi 10b041: c9 leave 10b042: c3 ret 10b043: 90 nop bool _wait, Watchdog_Interval _timeout, ISR_Level _level ) { _CORE_mutex_Seize_body( _the_mutex, _id, _wait, _timeout, _level ); 10b044: 83 3d 24 e8 11 00 01 cmpl $0x1,0x11e824 10b04b: 76 c7 jbe 10b014 <_CORE_mutex_Seize+0x18> 10b04d: 53 push %ebx 10b04e: 6a 13 push $0x13 10b050: 6a 00 push $0x0 10b052: 6a 00 push $0x0 10b054: e8 c7 04 00 00 call 10b520 <_Internal_error_Occurred> 10b059: 8d 76 00 lea 0x0(%esi),%esi { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10b05c: c7 46 30 01 00 00 00 movl $0x1,0x30(%esi) 10b063: a1 1c e7 11 00 mov 0x11e71c,%eax 10b068: 89 70 44 mov %esi,0x44(%eax) 10b06b: 8b 55 0c mov 0xc(%ebp),%edx 10b06e: 89 50 20 mov %edx,0x20(%eax) /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10b071: a1 58 e6 11 00 mov 0x11e658,%eax 10b076: 40 inc %eax 10b077: a3 58 e6 11 00 mov %eax,0x11e658 10b07c: ff 75 18 pushl 0x18(%ebp) 10b07f: 9d popf 10b080: 83 ec 08 sub $0x8,%esp 10b083: ff 75 14 pushl 0x14(%ebp) 10b086: 56 push %esi 10b087: e8 20 ff ff ff call 10afac <_CORE_mutex_Seize_interrupt_blocking> 10b08c: 83 c4 10 add $0x10,%esp } 10b08f: 8d 65 f8 lea -0x8(%ebp),%esp 10b092: 5b pop %ebx 10b093: 5e pop %esi 10b094: c9 leave 10b095: c3 ret =============================================================================== 0010f188 <_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 ) { 10f188: 55 push %ebp 10f189: 89 e5 mov %esp,%ebp 10f18b: 53 push %ebx 10f18c: 83 ec 04 sub $0x4,%esp 10f18f: 8b 4d 08 mov 0x8(%ebp),%ecx bool _Protected_heap_Get_block_size( Heap_Control *the_heap, void *starting_address, size_t *size ); 10f192: 8b 45 0c mov 0xc(%ebp),%eax 10f195: 8b 18 mov (%eax),%ebx /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * 10f197: 8b 15 1c e7 11 00 mov 0x11e71c,%edx * @param[in] the_heap is the heap to operate upon 10f19d: c7 42 34 00 00 00 00 movl $0x0,0x34(%edx) * @param[in] starting_address is the starting address of the user block 10f1a4: 8b 41 50 mov 0x50(%ecx),%eax 10f1a7: 85 c0 test %eax,%eax 10f1a9: 74 2d je 10f1d8 <_CORE_mutex_Seize_interrupt_trylock+0x50> * to be resized 10f1ab: c7 41 50 00 00 00 00 movl $0x0,0x50(%ecx) * @param[in] size is the new size 10f1b2: 89 51 5c mov %edx,0x5c(%ecx) * 10f1b5: 8b 42 08 mov 0x8(%edx),%eax 10f1b8: 89 41 60 mov %eax,0x60(%ecx) * @return TRUE if successfully able to resize the block. 10f1bb: c7 41 54 01 00 00 00 movl $0x1,0x54(%ecx) /** * 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 10f1c2: 8b 41 48 mov 0x48(%ecx),%eax * @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. 10f1c5: 83 f8 02 cmp $0x2,%eax 10f1c8: 74 1e je 10f1e8 <_CORE_mutex_Seize_interrupt_trylock+0x60><== ALWAYS TAKEN 10f1ca: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10f1cd: 74 19 je 10f1e8 <_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 10f1cf: 53 push %ebx 10f1d0: 9d popf 10f1d1: 31 c0 xor %eax,%eax return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); } 10f1d3: 8b 5d fc mov -0x4(%ebp),%ebx 10f1d6: c9 leave 10f1d7: c3 ret * 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. 10f1d8: 3b 51 5c cmp 0x5c(%ecx),%edx 10f1db: 74 3f je 10f21c <_CORE_mutex_Seize_interrupt_trylock+0x94> Heap_Control *the_heap, Heap_Information *info ); #ifdef __cplusplus } 10f1dd: b8 01 00 00 00 mov $0x1,%eax 10f1e2: 8b 5d fc mov -0x4(%ebp),%ebx 10f1e5: c9 leave 10f1e6: c3 ret 10f1e7: 90 nop void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10f1e8: ff 42 1c incl 0x1c(%edx) * at @a starting_address to @a the_heap. Any coalescing which is * possible with the freeing of this routine is performed. * 10f1eb: 83 79 48 03 cmpl $0x3,0x48(%ecx) 10f1ef: 75 de jne 10f1cf <_CORE_mutex_Seize_interrupt_trylock+0x47><== ALWAYS TAKEN void *start_address ); /** * This routine walks the heap to verify its integrity. * 10f1f1: 8b 42 14 mov 0x14(%edx),%eax <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10f1f4: 39 41 4c cmp %eax,0x4c(%ecx) <== NOT EXECUTED 10f1f7: 74 47 je 10f240 <_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. */ 10f1f9: 72 4d jb 10f248 <_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 10f1fb: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) <== NOT EXECUTED * 10f202: c7 41 50 01 00 00 00 movl $0x1,0x50(%ecx) <== NOT EXECUTED * @return true if successfully able to return information 10f209: c7 41 54 00 00 00 00 movl $0x0,0x54(%ecx) <== NOT EXECUTED */ 10f210: ff 4a 1c decl 0x1c(%edx) <== NOT EXECUTED bool _Protected_heap_Get_information( 10f213: 53 push %ebx <== NOT EXECUTED 10f214: 9d popf <== NOT EXECUTED 10f215: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f217: eb c9 jmp 10f1e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a><== NOT EXECUTED 10f219: 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. */ 10f21c: 8b 41 40 mov 0x40(%ecx),%eax 10f21f: 85 c0 test %eax,%eax 10f221: 74 11 je 10f234 <_CORE_mutex_Seize_interrupt_trylock+0xac> 10f223: 48 dec %eax 10f224: 75 b7 jne 10f1dd <_CORE_mutex_Seize_interrupt_trylock+0x55> bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ); #ifdef __cplusplus 10f226: c7 42 34 02 00 00 00 movl $0x2,0x34(%edx) } 10f22d: 53 push %ebx 10f22e: 9d popf 10f22f: 31 c0 xor %eax,%eax 10f231: eb af jmp 10f1e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 10f233: 90 nop * @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, 10f234: ff 41 54 incl 0x54(%ecx) Heap_Information *info 10f237: 53 push %ebx 10f238: 9d popf 10f239: 31 c0 xor %eax,%eax 10f23b: eb a5 jmp 10f1e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a> 10f23d: 8d 76 00 lea 0x0(%esi),%esi /** * 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 10f240: 53 push %ebx <== NOT EXECUTED 10f241: 9d popf <== NOT EXECUTED 10f242: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f244: eb 9c jmp 10f1e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a><== NOT EXECUTED 10f246: 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 10f248: a1 58 e6 11 00 mov 0x11e658,%eax <== NOT EXECUTED 10f24d: 40 inc %eax <== NOT EXECUTED 10f24e: a3 58 e6 11 00 mov %eax,0x11e658 <== 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, 10f253: 53 push %ebx <== NOT EXECUTED 10f254: 9d popf <== NOT EXECUTED int source, 10f255: 50 push %eax <== NOT EXECUTED 10f256: 6a 00 push $0x0 <== NOT EXECUTED 10f258: ff 71 4c pushl 0x4c(%ecx) <== NOT EXECUTED 10f25b: ff 71 5c pushl 0x5c(%ecx) <== NOT EXECUTED 10f25e: e8 ad cb ff ff call 10be10 <_Thread_Change_priority><== NOT EXECUTED bool do_dump ); /** * This routine walks the heap and tots up the free and allocated 10f263: e8 84 d0 ff ff call 10c2ec <_Thread_Enable_dispatch><== NOT EXECUTED 10f268: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f26a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f26d: e9 70 ff ff ff jmp 10f1e2 <_CORE_mutex_Seize_interrupt_trylock+0x5a><== NOT EXECUTED =============================================================================== 0010b098 <_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 ) { 10b098: 55 push %ebp 10b099: 89 e5 mov %esp,%ebp 10b09b: 53 push %ebx 10b09c: 83 ec 04 sub $0x4,%esp 10b09f: 8b 5d 08 mov 0x8(%ebp),%ebx Thread_Control *the_thread; Thread_Control *holder; #ifdef __RTEMS_STRICT_ORDER_MUTEX__ Chain_Node *first_node; #endif holder = the_mutex->holder; 10b0a2: 8b 53 5c mov 0x5c(%ebx),%edx * 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 ) { 10b0a5: 80 7b 44 00 cmpb $0x0,0x44(%ebx) 10b0a9: 74 15 je 10b0c0 <_CORE_mutex_Surrender+0x28> if ( !_Thread_Is_executing( holder ) ) 10b0ab: 3b 15 1c e7 11 00 cmp 0x11e71c,%edx 10b0b1: 74 0d je 10b0c0 <_CORE_mutex_Surrender+0x28> 10b0b3: b8 03 00 00 00 mov $0x3,%eax } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; return CORE_MUTEX_STATUS_SUCCESSFUL; } 10b0b8: 8b 5d fc mov -0x4(%ebp),%ebx 10b0bb: c9 leave 10b0bc: c3 ret 10b0bd: 8d 76 00 lea 0x0(%esi),%esi return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE; } /* XXX already unlocked -- not right status */ if ( !the_mutex->nest_count ) 10b0c0: 8b 43 54 mov 0x54(%ebx),%eax 10b0c3: 85 c0 test %eax,%eax 10b0c5: 74 69 je 10b130 <_CORE_mutex_Surrender+0x98> return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; 10b0c7: 48 dec %eax 10b0c8: 89 43 54 mov %eax,0x54(%ebx) if ( the_mutex->nest_count != 0 ) { 10b0cb: 85 c0 test %eax,%eax 10b0cd: 75 69 jne 10b138 <_CORE_mutex_Surrender+0xa0> /** * 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 10b0cf: 8b 43 48 mov 0x48(%ebx),%eax /* * Formally release the mutex before possibly transferring it to a * blocked thread. */ if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) || 10b0d2: 83 f8 02 cmp $0x2,%eax 10b0d5: 0f 84 91 00 00 00 je 10b16c <_CORE_mutex_Surrender+0xd4> 10b0db: 83 f8 03 cmp $0x3,%eax 10b0de: 0f 84 88 00 00 00 je 10b16c <_CORE_mutex_Surrender+0xd4><== NEVER TAKEN } first_node = _Chain_Get_first_unprotected(&holder->lock_mutex); #endif holder->resource_count--; } the_mutex->holder = NULL; 10b0e4: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx) the_mutex->holder_id = 0; 10b0eb: c7 43 60 00 00 00 00 movl $0x0,0x60(%ebx) /* * 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 ) || 10b0f2: 83 f8 02 cmp $0x2,%eax 10b0f5: 74 55 je 10b14c <_CORE_mutex_Surrender+0xb4> 10b0f7: 83 f8 03 cmp $0x3,%eax 10b0fa: 74 50 je 10b14c <_CORE_mutex_Surrender+0xb4><== NEVER TAKEN /* * 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 ) ) ) { 10b0fc: 83 ec 0c sub $0xc,%esp 10b0ff: 53 push %ebx 10b100: e8 6b 15 00 00 call 10c670 <_Thread_queue_Dequeue> 10b105: 89 c2 mov %eax,%edx 10b107: 83 c4 10 add $0x10,%esp 10b10a: 85 c0 test %eax,%eax 10b10c: 0f 84 8e 00 00 00 je 10b1a0 <_CORE_mutex_Surrender+0x108> } else #endif { the_mutex->holder = the_thread; 10b112: 89 43 5c mov %eax,0x5c(%ebx) the_mutex->holder_id = the_thread->Object.id; 10b115: 8b 40 08 mov 0x8(%eax),%eax 10b118: 89 43 60 mov %eax,0x60(%ebx) the_mutex->nest_count = 1; 10b11b: c7 43 54 01 00 00 00 movl $0x1,0x54(%ebx) switch ( the_mutex->Attributes.discipline ) { 10b122: 8b 43 48 mov 0x48(%ebx),%eax 10b125: 83 f8 02 cmp $0x2,%eax 10b128: 74 6a je 10b194 <_CORE_mutex_Surrender+0xfc> 10b12a: 83 f8 03 cmp $0x3,%eax 10b12d: 74 45 je 10b174 <_CORE_mutex_Surrender+0xdc><== NEVER TAKEN 10b12f: 90 nop } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 10b130: 31 c0 xor %eax,%eax return CORE_MUTEX_STATUS_SUCCESSFUL; } 10b132: 8b 5d fc mov -0x4(%ebp),%ebx 10b135: c9 leave 10b136: c3 ret 10b137: 90 nop return CORE_MUTEX_STATUS_SUCCESSFUL; the_mutex->nest_count--; if ( the_mutex->nest_count != 0 ) { switch ( the_mutex->Attributes.lock_nesting_behavior ) { 10b138: 8b 43 40 mov 0x40(%ebx),%eax 10b13b: 85 c0 test %eax,%eax 10b13d: 74 f1 je 10b130 <_CORE_mutex_Surrender+0x98><== ALWAYS TAKEN 10b13f: 48 dec %eax <== NOT EXECUTED 10b140: 75 8d jne 10b0cf <_CORE_mutex_Surrender+0x37><== NOT EXECUTED 10b142: b8 02 00 00 00 mov $0x2,%eax <== NOT EXECUTED 10b147: e9 6c ff ff ff jmp 10b0b8 <_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 && 10b14c: 8b 42 1c mov 0x1c(%edx),%eax 10b14f: 85 c0 test %eax,%eax 10b151: 75 a9 jne 10b0fc <_CORE_mutex_Surrender+0x64> 10b153: 8b 42 18 mov 0x18(%edx),%eax 10b156: 3b 42 14 cmp 0x14(%edx),%eax 10b159: 74 a1 je 10b0fc <_CORE_mutex_Surrender+0x64> holder->real_priority != holder->current_priority ) { _Thread_Change_priority( holder, holder->real_priority, TRUE ); 10b15b: 51 push %ecx 10b15c: 6a 01 push $0x1 10b15e: 50 push %eax 10b15f: 52 push %edx 10b160: e8 ab 0c 00 00 call 10be10 <_Thread_Change_priority> 10b165: 83 c4 10 add $0x10,%esp 10b168: eb 92 jmp 10b0fc <_CORE_mutex_Surrender+0x64> 10b16a: 66 90 xchg %ax,%ax the_mutex->nest_count++; return CORE_MUTEX_RELEASE_NOT_ORDER; } first_node = _Chain_Get_first_unprotected(&holder->lock_mutex); #endif holder->resource_count--; 10b16c: ff 4a 1c decl 0x1c(%edx) 10b16f: e9 70 ff ff ff jmp 10b0e4 <_CORE_mutex_Surrender+0x4c> 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++; 10b174: ff 42 1c incl 0x1c(%edx) <== NOT EXECUTED if (the_mutex->Attributes.priority_ceiling < 10b177: 8b 43 4c mov 0x4c(%ebx),%eax <== NOT EXECUTED 10b17a: 3b 42 14 cmp 0x14(%edx),%eax <== NOT EXECUTED 10b17d: 73 b1 jae 10b130 <_CORE_mutex_Surrender+0x98><== NOT EXECUTED the_thread->current_priority){ _Thread_Change_priority( 10b17f: 51 push %ecx <== NOT EXECUTED 10b180: 6a 00 push $0x0 <== NOT EXECUTED 10b182: 50 push %eax <== NOT EXECUTED 10b183: 52 push %edx <== NOT EXECUTED 10b184: e8 87 0c 00 00 call 10be10 <_Thread_Change_priority><== NOT EXECUTED 10b189: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b18b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b18e: e9 25 ff ff ff jmp 10b0b8 <_CORE_mutex_Surrender+0x20><== NOT EXECUTED 10b193: 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++; 10b194: ff 42 1c incl 0x1c(%edx) 10b197: 31 c0 xor %eax,%eax 10b199: e9 1a ff ff ff jmp 10b0b8 <_CORE_mutex_Surrender+0x20> 10b19e: 66 90 xchg %ax,%ax } break; } } } else the_mutex->lock = CORE_MUTEX_UNLOCKED; 10b1a0: c7 43 50 01 00 00 00 movl $0x1,0x50(%ebx) 10b1a7: 31 c0 xor %eax,%eax 10b1a9: e9 0a ff ff ff jmp 10b0b8 <_CORE_mutex_Surrender+0x20> =============================================================================== 0010b1fc <_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 ) { 10b1fc: 55 push %ebp 10b1fd: 89 e5 mov %esp,%ebp 10b1ff: 53 push %ebx 10b200: 83 ec 10 sub $0x10,%esp 10b203: 8b 5d 08 mov 0x8(%ebp),%ebx ISR_Level level; CORE_semaphore_Status status; status = CORE_SEMAPHORE_STATUS_SUCCESSFUL; if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) { 10b206: 53 push %ebx 10b207: e8 64 14 00 00 call 10c670 <_Thread_queue_Dequeue> 10b20c: 83 c4 10 add $0x10,%esp 10b20f: 85 c0 test %eax,%eax 10b211: 74 09 je 10b21c <_CORE_semaphore_Surrender+0x20> 10b213: 31 c0 xor %eax,%eax status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); } return status; } 10b215: 8b 5d fc mov -0x4(%ebp),%ebx 10b218: c9 leave 10b219: c3 ret 10b21a: 66 90 xchg %ax,%ax if ( !_Objects_Is_local_id( the_thread->Object.id ) ) (*api_semaphore_mp_support) ( the_thread, id ); #endif } else { _ISR_Disable( level ); 10b21c: 9c pushf 10b21d: fa cli 10b21e: 5a pop %edx if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) 10b21f: 8b 43 48 mov 0x48(%ebx),%eax 10b222: 3b 43 40 cmp 0x40(%ebx),%eax 10b225: 72 0d jb 10b234 <_CORE_semaphore_Surrender+0x38><== ALWAYS TAKEN 10b227: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED the_semaphore->count += 1; else status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED; _ISR_Enable( level ); 10b22c: 52 push %edx 10b22d: 9d popf } return status; } 10b22e: 8b 5d fc mov -0x4(%ebp),%ebx 10b231: c9 leave 10b232: c3 ret 10b233: 90 nop #endif } else { _ISR_Disable( level ); if ( the_semaphore->count < the_semaphore->Attributes.maximum_count ) the_semaphore->count += 1; 10b234: 40 inc %eax 10b235: 89 43 48 mov %eax,0x48(%ebx) 10b238: 31 c0 xor %eax,%eax 10b23a: eb f0 jmp 10b22c <_CORE_semaphore_Surrender+0x30> =============================================================================== 0010ada0 <_Chain_Get>: */ Chain_Node *_Chain_Get( Chain_Control *the_chain ) { 10ada0: 55 push %ebp 10ada1: 89 e5 mov %esp,%ebp 10ada3: 53 push %ebx 10ada4: 8b 4d 08 mov 0x8(%ebp),%ecx ISR_Level level; Chain_Node *return_node; return_node = NULL; _ISR_Disable( level ); 10ada7: 9c pushf 10ada8: fa cli 10ada9: 5b pop %ebx * 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( 10adaa: 8b 11 mov (%ecx),%edx if ( !_Chain_Is_empty( the_chain ) ) 10adac: 8d 41 04 lea 0x4(%ecx),%eax 10adaf: 39 c2 cmp %eax,%edx 10adb1: 74 11 je 10adc4 <_Chain_Get+0x24> 10adb3: 8b 02 mov (%edx),%eax 10adb5: 89 01 mov %eax,(%ecx) 10adb7: 89 48 04 mov %ecx,0x4(%eax) return_node = _Chain_Get_first_unprotected( the_chain ); _ISR_Enable( level ); 10adba: 53 push %ebx 10adbb: 9d popf return return_node; } 10adbc: 89 d0 mov %edx,%eax 10adbe: 5b pop %ebx 10adbf: c9 leave 10adc0: c3 ret 10adc1: 8d 76 00 lea 0x0(%esi),%esi ISR_Level level; Chain_Node *return_node; return_node = NULL; _ISR_Disable( level ); if ( !_Chain_Is_empty( the_chain ) ) 10adc4: 31 d2 xor %edx,%edx 10adc6: eb f2 jmp 10adba <_Chain_Get+0x1a> =============================================================================== 0010f05c <_Chain_Initialize>: Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10f05c: 55 push %ebp 10f05d: 89 e5 mov %esp,%ebp 10f05f: 57 push %edi 10f060: 56 push %esi 10f061: 53 push %ebx 10f062: 8b 75 08 mov 0x8(%ebp),%esi 10f065: 8b 45 10 mov 0x10(%ebp),%eax 10f068: 8b 5d 14 mov 0x14(%ebp),%ebx 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 10f06b: 89 f1 mov %esi,%ecx Chain_Node *current; Chain_Node *next; count = number_nodes; current = _Chain_Head( the_chain ); the_chain->permanent_null = NULL; 10f06d: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi) next = starting_address; while ( count-- ) { 10f074: 85 c0 test %eax,%eax 10f076: 74 22 je 10f09a <_Chain_Initialize+0x3e><== NEVER TAKEN 10f078: 8d 50 ff lea -0x1(%eax),%edx 10f07b: 89 d7 mov %edx,%edi 10f07d: 8b 45 0c mov 0xc(%ebp),%eax 10f080: eb 03 jmp 10f085 <_Chain_Initialize+0x29> 10f082: 66 90 xchg %ax,%ax 10f084: 4a dec %edx current->next = next; 10f085: 89 01 mov %eax,(%ecx) next->previous = current; 10f087: 89 48 04 mov %ecx,0x4(%eax) Chain_Control *the_chain, void *starting_address, size_t number_nodes, size_t node_size ) { 10f08a: 89 c1 mov %eax,%ecx 10f08c: 01 d8 add %ebx,%eax count = number_nodes; current = _Chain_Head( the_chain ); the_chain->permanent_null = NULL; next = starting_address; while ( count-- ) { 10f08e: 85 d2 test %edx,%edx 10f090: 75 f2 jne 10f084 <_Chain_Initialize+0x28> 10f092: 0f af df imul %edi,%ebx 10f095: 8b 4d 0c mov 0xc(%ebp),%ecx 10f098: 01 d9 add %ebx,%ecx next->previous = current; current = next; next = (Chain_Node *) _Addresses_Add_offset( (void *) next, node_size ); } current->next = _Chain_Tail( the_chain ); 10f09a: 8d 46 04 lea 0x4(%esi),%eax 10f09d: 89 01 mov %eax,(%ecx) the_chain->last = current; 10f09f: 89 4e 08 mov %ecx,0x8(%esi) } 10f0a2: 5b pop %ebx 10f0a3: 5e pop %esi 10f0a4: 5f pop %edi 10f0a5: c9 leave 10f0a6: c3 ret =============================================================================== 0010eff0 <_Debug_Is_enabled>: */ bool _Debug_Is_enabled( rtems_debug_control level ) { 10eff0: 55 push %ebp <== NOT EXECUTED 10eff1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10eff3: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10eff6: 85 05 20 e7 11 00 test %eax,0x11e720 <== NOT EXECUTED 10effc: 0f 95 c0 setne %al <== NOT EXECUTED return (_Debug_Level & level) ? true : false; } 10efff: c9 leave <== NOT EXECUTED 10f000: c3 ret <== NOT EXECUTED =============================================================================== 00109d94 <_Event_Seize>: rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 109d94: 55 push %ebp 109d95: 89 e5 mov %esp,%ebp 109d97: 57 push %edi 109d98: 56 push %esi 109d99: 53 push %ebx 109d9a: 83 ec 0c sub $0xc,%esp 109d9d: 8b 45 08 mov 0x8(%ebp),%eax 109da0: 8b 75 0c mov 0xc(%ebp),%esi 109da3: 8b 55 10 mov 0x10(%ebp),%edx 109da6: 89 55 ec mov %edx,-0x14(%ebp) 109da9: 8b 55 14 mov 0x14(%ebp),%edx 109dac: 89 55 e8 mov %edx,-0x18(%ebp) rtems_event_set pending_events; ISR_Level level; RTEMS_API_Control *api; Thread_blocking_operation_States sync_state; executing = _Thread_Executing; 109daf: 8b 1d 1c e7 11 00 mov 0x11e71c,%ebx executing->Wait.return_code = RTEMS_SUCCESSFUL; 109db5: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) api = executing->API_Extensions[ THREAD_API_RTEMS ]; 109dbc: 8b bb f4 00 00 00 mov 0xf4(%ebx),%edi _ISR_Disable( level ); 109dc2: 9c pushf 109dc3: fa cli 109dc4: 8f 45 f0 popl -0x10(%ebp) pending_events = api->pending_events; 109dc7: 8b 17 mov (%edi),%edx seized_events = _Event_sets_Get( pending_events, event_in ); if ( !_Event_sets_Is_empty( seized_events ) && 109dc9: 89 c1 mov %eax,%ecx 109dcb: 21 d1 and %edx,%ecx 109dcd: 74 14 je 109de3 <_Event_Seize+0x4f> 109dcf: 39 c8 cmp %ecx,%eax 109dd1: 0f 84 91 00 00 00 je 109e68 <_Event_Seize+0xd4> 109dd7: f7 c6 02 00 00 00 test $0x2,%esi 109ddd: 0f 85 85 00 00 00 jne 109e68 <_Event_Seize+0xd4> <== ALWAYS TAKEN _ISR_Enable( level ); *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { 109de3: f7 c6 01 00 00 00 test $0x1,%esi 109de9: 75 65 jne 109e50 <_Event_Seize+0xbc> executing->Wait.return_code = RTEMS_UNSATISFIED; *event_out = seized_events; return; } _Event_Sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; 109deb: c7 05 6c e9 11 00 01 movl $0x1,0x11e96c 109df2: 00 00 00 executing->Wait.option = (uint32_t) option_set; 109df5: 89 73 30 mov %esi,0x30(%ebx) executing->Wait.count = (uint32_t) event_in; 109df8: 89 43 24 mov %eax,0x24(%ebx) executing->Wait.return_argument = event_out; 109dfb: 8b 45 e8 mov -0x18(%ebp),%eax 109dfe: 89 43 28 mov %eax,0x28(%ebx) _ISR_Enable( level ); 109e01: ff 75 f0 pushl -0x10(%ebp) 109e04: 9d popf if ( ticks ) { 109e05: 8b 45 ec mov -0x14(%ebp),%eax 109e08: 85 c0 test %eax,%eax 109e0a: 0f 85 80 00 00 00 jne 109e90 <_Event_Seize+0xfc> NULL ); _Watchdog_Insert_ticks( &executing->Timer, ticks ); } _Thread_Set_state( executing, STATES_WAITING_FOR_EVENT ); 109e10: 83 ec 08 sub $0x8,%esp 109e13: 68 00 01 00 00 push $0x100 109e18: 53 push %ebx 109e19: e8 82 2d 00 00 call 10cba0 <_Thread_Set_state> _ISR_Disable( level ); 109e1e: 9c pushf 109e1f: fa cli 109e20: 5a pop %edx sync_state = _Event_Sync_state; 109e21: a1 6c e9 11 00 mov 0x11e96c,%eax _Event_Sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 109e26: c7 05 6c e9 11 00 00 movl $0x0,0x11e96c 109e2d: 00 00 00 if ( sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) { 109e30: 83 c4 10 add $0x10,%esp 109e33: 83 f8 01 cmp $0x1,%eax 109e36: 74 4c je 109e84 <_Event_Seize+0xf0> * 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 ); 109e38: 89 55 10 mov %edx,0x10(%ebp) 109e3b: 89 5d 0c mov %ebx,0xc(%ebp) 109e3e: 89 45 08 mov %eax,0x8(%ebp) } 109e41: 8d 65 f4 lea -0xc(%ebp),%esp 109e44: 5b pop %ebx 109e45: 5e pop %esi 109e46: 5f pop %edi 109e47: c9 leave * 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 ); 109e48: e9 77 1f 00 00 jmp 10bdc4 <_Thread_blocking_operation_Cancel> 109e4d: 8d 76 00 lea 0x0(%esi),%esi *event_out = seized_events; return; } if ( _Options_Is_no_wait( option_set ) ) { _ISR_Enable( level ); 109e50: ff 75 f0 pushl -0x10(%ebp) 109e53: 9d popf executing->Wait.return_code = RTEMS_UNSATISFIED; 109e54: c7 43 34 0d 00 00 00 movl $0xd,0x34(%ebx) *event_out = seized_events; 109e5b: 8b 55 e8 mov -0x18(%ebp),%edx 109e5e: 89 0a mov %ecx,(%edx) * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); } 109e60: 8d 65 f4 lea -0xc(%ebp),%esp 109e63: 5b pop %ebx 109e64: 5e pop %esi 109e65: 5f pop %edi 109e66: c9 leave 109e67: c3 ret 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 = 109e68: 89 c8 mov %ecx,%eax 109e6a: f7 d0 not %eax 109e6c: 21 d0 and %edx,%eax 109e6e: 89 07 mov %eax,(%edi) _Event_sets_Clear( pending_events, seized_events ); _ISR_Enable( level ); 109e70: ff 75 f0 pushl -0x10(%ebp) 109e73: 9d popf *event_out = seized_events; 109e74: 8b 45 e8 mov -0x18(%ebp),%eax 109e77: 89 08 mov %ecx,(%eax) * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); } 109e79: 8d 65 f4 lea -0xc(%ebp),%esp 109e7c: 5b pop %ebx 109e7d: 5e pop %esi 109e7e: 5f pop %edi 109e7f: c9 leave 109e80: c3 ret 109e81: 8d 76 00 lea 0x0(%esi),%esi _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 ); 109e84: 52 push %edx 109e85: 9d popf * The blocking thread was satisfied by an ISR or timed out. * * WARNING! Returning with interrupts disabled! */ _Thread_blocking_operation_Cancel( sync_state, executing, level ); } 109e86: 8d 65 f4 lea -0xc(%ebp),%esp 109e89: 5b pop %ebx 109e8a: 5e pop %esi 109e8b: 5f pop %edi 109e8c: c9 leave 109e8d: c3 ret 109e8e: 66 90 xchg %ax,%ax executing->Wait.return_argument = event_out; _ISR_Enable( level ); if ( ticks ) { _Watchdog_Initialize( 109e90: 8b 43 08 mov 0x8(%ebx),%eax * 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. * 109e93: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) * @param[in] the_heap is the heap to operate upon 109e9a: c7 43 64 38 a0 10 00 movl $0x10a038,0x64(%ebx) * @param[in] starting_address is the starting address of the memory for 109ea1: 89 43 68 mov %eax,0x68(%ebx) * the heap 109ea4: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) * @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, 109eab: 8b 55 ec mov -0x14(%ebp),%edx 109eae: 89 53 54 mov %edx,0x54(%ebx) void *starting_address, size_t *size 109eb1: 83 ec 08 sub $0x8,%esp 109eb4: 8d 43 48 lea 0x48(%ebx),%eax 109eb7: 50 push %eax 109eb8: 68 3c e7 11 00 push $0x11e73c 109ebd: e8 3a 33 00 00 call 10d1fc <_Watchdog_Insert> 109ec2: 83 c4 10 add $0x10,%esp 109ec5: e9 46 ff ff ff jmp 109e10 <_Event_Seize+0x7c> =============================================================================== 00109f20 <_Event_Surrender>: */ void _Event_Surrender( Thread_Control *the_thread ) { 109f20: 55 push %ebp 109f21: 89 e5 mov %esp,%ebp 109f23: 57 push %edi 109f24: 56 push %esi 109f25: 53 push %ebx 109f26: 83 ec 0c sub $0xc,%esp 109f29: 8b 5d 08 mov 0x8(%ebp),%ebx 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 ]; 109f2c: 8b b3 f4 00 00 00 mov 0xf4(%ebx),%esi option_set = (rtems_option) the_thread->Wait.option; 109f32: 8b 43 30 mov 0x30(%ebx),%eax 109f35: 89 45 f0 mov %eax,-0x10(%ebp) _ISR_Disable( level ); 109f38: 9c pushf 109f39: fa cli 109f3a: 8f 45 ec popl -0x14(%ebp) pending_events = api->pending_events; 109f3d: 8b 0e mov (%esi),%ecx event_condition = (rtems_event_set) the_thread->Wait.count; 109f3f: 8b 53 24 mov 0x24(%ebx),%edx seized_events = _Event_sets_Get( pending_events, event_condition ); /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { 109f42: 89 d7 mov %edx,%edi 109f44: 21 cf and %ecx,%edi 109f46: 74 70 je 109fb8 <_Event_Surrender+0x98> /* * 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() && 109f48: a1 f8 e6 11 00 mov 0x11e6f8,%eax 109f4d: 85 c0 test %eax,%eax 109f4f: 74 0c je 109f5d <_Event_Surrender+0x3d> 109f51: 3b 1d 1c e7 11 00 cmp 0x11e71c,%ebx 109f57: 0f 84 93 00 00 00 je 109ff0 <_Event_Surrender+0xd0> } /* * Otherwise, this is a normal send to another thread */ if ( _States_Is_waiting_for_event( the_thread->current_state ) ) { 109f5d: f6 43 11 01 testb $0x1,0x11(%ebx) 109f61: 75 0d jne 109f70 <_Event_Surrender+0x50> <== ALWAYS TAKEN _Thread_Unblock( the_thread ); } return; } } _ISR_Enable( level ); 109f63: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 109f66: 9d popf <== NOT EXECUTED } 109f67: 8d 65 f4 lea -0xc(%ebp),%esp 109f6a: 5b pop %ebx 109f6b: 5e pop %esi 109f6c: 5f pop %edi 109f6d: c9 leave 109f6e: c3 ret 109f6f: 90 nop /* * 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 ) ) { 109f70: 39 fa cmp %edi,%edx 109f72: 74 06 je 109f7a <_Event_Surrender+0x5a> 109f74: f6 45 f0 02 testb $0x2,-0x10(%ebp) 109f78: 74 e9 je 109f63 <_Event_Surrender+0x43> <== NEVER TAKEN api->pending_events = _Event_sets_Clear( pending_events, seized_events ); 109f7a: 89 f8 mov %edi,%eax 109f7c: f7 d0 not %eax 109f7e: 21 c8 and %ecx,%eax 109f80: 89 06 mov %eax,(%esi) the_thread->Wait.count = 0; 109f82: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 109f89: 8b 43 28 mov 0x28(%ebx),%eax 109f8c: 89 38 mov %edi,(%eax) _ISR_Flash( level ); 109f8e: ff 75 ec pushl -0x14(%ebp) 109f91: 9d popf 109f92: fa cli if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 109f93: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 109f97: 74 2b je 109fc4 <_Event_Surrender+0xa4> _ISR_Enable( level ); 109f99: ff 75 ec pushl -0x14(%ebp) 109f9c: 9d popf void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 109f9d: 83 ec 08 sub $0x8,%esp 109fa0: 68 f8 ff 03 10 push $0x1003fff8 109fa5: 53 push %ebx 109fa6: e8 99 1f 00 00 call 10bf44 <_Thread_Clear_state> 109fab: 83 c4 10 add $0x10,%esp } return; } } _ISR_Enable( level ); } 109fae: 8d 65 f4 lea -0xc(%ebp),%esp 109fb1: 5b pop %ebx 109fb2: 5e pop %esi 109fb3: 5f pop %edi 109fb4: c9 leave 109fb5: c3 ret 109fb6: 66 90 xchg %ax,%ax /* * No events were seized in this operation */ if ( _Event_sets_Is_empty( seized_events ) ) { _ISR_Enable( level ); 109fb8: ff 75 ec pushl -0x14(%ebp) 109fbb: 9d popf } return; } } _ISR_Enable( level ); } 109fbc: 8d 65 f4 lea -0xc(%ebp),%esp 109fbf: 5b pop %ebx 109fc0: 5e pop %esi 109fc1: 5f pop %edi 109fc2: c9 leave 109fc3: c3 ret * 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 */ 109fc4: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 109fcb: ff 75 ec pushl -0x14(%ebp) 109fce: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 109fcf: 83 ec 0c sub $0xc,%esp 109fd2: 8d 43 48 lea 0x48(%ebx),%eax 109fd5: 50 push %eax 109fd6: e8 51 33 00 00 call 10d32c <_Watchdog_Remove> void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 109fdb: 58 pop %eax 109fdc: 5a pop %edx 109fdd: 68 f8 ff 03 10 push $0x1003fff8 109fe2: 53 push %ebx 109fe3: e8 5c 1f 00 00 call 10bf44 <_Thread_Clear_state> 109fe8: 83 c4 10 add $0x10,%esp 109feb: e9 77 ff ff ff jmp 109f67 <_Event_Surrender+0x47> /* * 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() && 109ff0: a1 6c e9 11 00 mov 0x11e96c,%eax 109ff5: 48 dec %eax 109ff6: 74 0e je 10a006 <_Event_Surrender+0xe6> <== ALWAYS TAKEN 109ff8: a1 6c e9 11 00 mov 0x11e96c,%eax <== NOT EXECUTED 109ffd: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 10a000: 0f 85 57 ff ff ff jne 109f5d <_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) ) { 10a006: 39 fa cmp %edi,%edx 10a008: 74 06 je 10a010 <_Event_Surrender+0xf0> <== ALWAYS TAKEN 10a00a: f6 45 f0 02 testb $0x2,-0x10(%ebp) <== NOT EXECUTED 10a00e: 74 1e je 10a02e <_Event_Surrender+0x10e><== NOT EXECUTED api->pending_events = _Event_sets_Clear( pending_events,seized_events ); 10a010: 89 f8 mov %edi,%eax 10a012: f7 d0 not %eax 10a014: 21 c8 and %ecx,%eax 10a016: 89 06 mov %eax,(%esi) the_thread->Wait.count = 0; 10a018: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx) *(rtems_event_set *)the_thread->Wait.return_argument = seized_events; 10a01f: 8b 43 28 mov 0x28(%ebx),%eax 10a022: 89 38 mov %edi,(%eax) _Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED; 10a024: c7 05 6c e9 11 00 03 movl $0x3,0x11e96c 10a02b: 00 00 00 } _ISR_Enable( level ); 10a02e: ff 75 ec pushl -0x14(%ebp) 10a031: 9d popf 10a032: e9 30 ff ff ff jmp 109f67 <_Event_Surrender+0x47> =============================================================================== 0010a038 <_Event_Timeout>: void _Event_Timeout( Objects_Id id, void *ignored ) { 10a038: 55 push %ebp 10a039: 89 e5 mov %esp,%ebp 10a03b: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; ISR_Level level; the_thread = _Thread_Get( id, &location ); 10a03e: 8d 45 fc lea -0x4(%ebp),%eax 10a041: 50 push %eax 10a042: ff 75 08 pushl 0x8(%ebp) 10a045: e8 c6 22 00 00 call 10c310 <_Thread_Get> 10a04a: 89 c2 mov %eax,%edx switch ( location ) { 10a04c: 83 c4 10 add $0x10,%esp 10a04f: 8b 4d fc mov -0x4(%ebp),%ecx 10a052: 85 c9 test %ecx,%ecx 10a054: 75 3e jne 10a094 <_Event_Timeout+0x5c> <== NEVER TAKEN * this is the "timeout" transition. After a request is satisfied, * a timeout is not allowed to occur. */ _ISR_Disable( level ); 10a056: 9c pushf 10a057: fa cli 10a058: 59 pop %ecx if ( !the_thread->Wait.count ) { /* verify thread is waiting */ 10a059: 8b 40 24 mov 0x24(%eax),%eax 10a05c: 85 c0 test %eax,%eax 10a05e: 74 38 je 10a098 <_Event_Timeout+0x60> <== NEVER TAKEN _Thread_Unnest_dispatch(); _ISR_Enable( level ); return; } the_thread->Wait.count = 0; 10a060: c7 42 24 00 00 00 00 movl $0x0,0x24(%edx) if ( _Thread_Is_executing( the_thread ) ) { 10a067: 3b 15 1c e7 11 00 cmp 0x11e71c,%edx 10a06d: 74 39 je 10a0a8 <_Event_Timeout+0x70> (sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; } } the_thread->Wait.return_code = RTEMS_TIMEOUT; 10a06f: c7 42 34 06 00 00 00 movl $0x6,0x34(%edx) _ISR_Enable( level ); 10a076: 51 push %ecx 10a077: 9d popf 10a078: 83 ec 08 sub $0x8,%esp 10a07b: 68 f8 ff 03 10 push $0x1003fff8 10a080: 52 push %edx 10a081: e8 be 1e 00 00 call 10bf44 <_Thread_Clear_state> 10a086: a1 58 e6 11 00 mov 0x11e658,%eax 10a08b: 48 dec %eax 10a08c: a3 58 e6 11 00 mov %eax,0x11e658 10a091: 83 c4 10 add $0x10,%esp case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10a094: c9 leave 10a095: c3 ret 10a096: 66 90 xchg %ax,%ax 10a098: a1 58 e6 11 00 mov 0x11e658,%eax <== NOT EXECUTED 10a09d: 48 dec %eax <== NOT EXECUTED 10a09e: a3 58 e6 11 00 mov %eax,0x11e658 <== NOT EXECUTED _ISR_Disable( level ); if ( !the_thread->Wait.count ) { /* verify thread is waiting */ _Thread_Unnest_dispatch(); _ISR_Enable( level ); 10a0a3: 51 push %ecx <== NOT EXECUTED 10a0a4: 9d popf <== NOT EXECUTED case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10a0a5: c9 leave <== NOT EXECUTED 10a0a6: c3 ret <== NOT EXECUTED 10a0a7: 90 nop <== NOT EXECUTED return; } the_thread->Wait.count = 0; if ( _Thread_Is_executing( the_thread ) ) { Thread_blocking_operation_States sync = _Event_Sync_state; 10a0a8: a1 6c e9 11 00 mov 0x11e96c,%eax if ( (sync == THREAD_BLOCKING_OPERATION_SYNCHRONIZED) || 10a0ad: 83 f8 01 cmp $0x1,%eax 10a0b0: 77 bd ja 10a06f <_Event_Timeout+0x37> <== NEVER TAKEN (sync == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED) ) { _Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10a0b2: c7 05 6c e9 11 00 02 movl $0x2,0x11e96c 10a0b9: 00 00 00 10a0bc: eb b1 jmp 10a06f <_Event_Timeout+0x37> =============================================================================== 0010f2c8 <_Heap_Allocate>: void *_Heap_Allocate( Heap_Control *the_heap, size_t size ) { 10f2c8: 55 push %ebp 10f2c9: 89 e5 mov %esp,%ebp 10f2cb: 57 push %edi 10f2cc: 56 push %esi 10f2cd: 53 push %ebx 10f2ce: 83 ec 10 sub $0x10,%esp 10f2d1: 8b 7d 08 mov 0x8(%ebp),%edi Heap_Block *the_block; void *ptr = NULL; Heap_Statistics *const stats = &the_heap->stats; Heap_Block *const tail = _Heap_Tail(the_heap); the_size = 10f2d4: ff 77 14 pushl 0x14(%edi) 10f2d7: ff 77 10 pushl 0x10(%edi) 10f2da: ff 75 0c pushl 0xc(%ebp) 10f2dd: e8 86 c1 ff ff call 10b468 <_Heap_Calc_block_size> _Heap_Calc_block_size(size, the_heap->page_size, the_heap->min_block_size); if(the_size == 0) 10f2e2: 83 c4 10 add $0x10,%esp 10f2e5: 85 c0 test %eax,%eax 10f2e7: 74 3b je 10f324 <_Heap_Allocate+0x5c> <== NEVER TAKEN * @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( 10f2e9: 8b 5f 08 mov 0x8(%edi),%ebx return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 10f2ec: 39 df cmp %ebx,%edi 10f2ee: 74 34 je 10f324 <_Heap_Allocate+0x5c> /* 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) { 10f2f0: 3b 43 04 cmp 0x4(%ebx),%eax 10f2f3: 76 5c jbe 10f351 <_Heap_Allocate+0x89> stats->allocs += 1; stats->searches += search_count + 1; _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; 10f2f5: 31 f6 xor %esi,%esi 10f2f7: eb 08 jmp 10f301 <_Heap_Allocate+0x39> 10f2f9: 8d 76 00 lea 0x0(%esi),%esi /* 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) { 10f2fc: 3b 43 04 cmp 0x4(%ebx),%eax 10f2ff: 76 2f jbe 10f330 <_Heap_Allocate+0x68> 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) 10f301: 8b 5b 08 mov 0x8(%ebx),%ebx 10f304: 46 inc %esi if(the_size == 0) return NULL; /* Find large enough free block. */ for(the_block = _Heap_First(the_heap), search_count = 0; the_block != tail; 10f305: 39 df cmp %ebx,%edi 10f307: 75 f3 jne 10f2fc <_Heap_Allocate+0x34> 10f309: 89 75 f0 mov %esi,-0x10(%ebp) 10f30c: 31 d2 xor %edx,%edx _HAssert(_Heap_Is_aligned_ptr(ptr, the_heap->page_size)); break; } } if(stats->max_search < search_count) 10f30e: 8b 45 f0 mov -0x10(%ebp),%eax 10f311: 39 47 44 cmp %eax,0x44(%edi) 10f314: 73 03 jae 10f319 <_Heap_Allocate+0x51> stats->max_search = search_count; 10f316: 89 47 44 mov %eax,0x44(%edi) return ptr; } 10f319: 89 d0 mov %edx,%eax 10f31b: 8d 65 f4 lea -0xc(%ebp),%esp 10f31e: 5b pop %ebx 10f31f: 5e pop %esi 10f320: 5f pop %edi 10f321: c9 leave 10f322: c3 ret 10f323: 90 nop break; } } if(stats->max_search < search_count) stats->max_search = search_count; 10f324: 31 d2 xor %edx,%edx return ptr; } 10f326: 89 d0 mov %edx,%eax 10f328: 8d 65 f4 lea -0xc(%ebp),%esp 10f32b: 5b pop %ebx 10f32c: 5e pop %esi 10f32d: 5f pop %edi 10f32e: c9 leave 10f32f: c3 ret /* 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) { 10f330: 89 75 f0 mov %esi,-0x10(%ebp) (void)_Heap_Block_allocate(the_heap, the_block, the_size ); 10f333: 52 push %edx 10f334: 50 push %eax 10f335: 53 push %ebx 10f336: 57 push %edi 10f337: e8 60 c1 ff ff call 10b49c <_Heap_Block_allocate> * @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 10f33c: 8d 53 08 lea 0x8(%ebx),%edx ptr = _Heap_User_area(the_block); stats->allocs += 1; 10f33f: ff 47 48 incl 0x48(%edi) stats->searches += search_count + 1; 10f342: 8b 47 4c mov 0x4c(%edi),%eax 10f345: 8d 44 06 01 lea 0x1(%esi,%eax,1),%eax 10f349: 89 47 4c mov %eax,0x4c(%edi) 10f34c: 83 c4 10 add $0x10,%esp 10f34f: eb bd jmp 10f30e <_Heap_Allocate+0x46> /* 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) { 10f351: 31 f6 xor %esi,%esi 10f353: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) 10f35a: eb d7 jmp 10f333 <_Heap_Allocate+0x6b> =============================================================================== 0010cc60 <_Heap_Allocate_aligned>: void *_Heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ) { 10cc60: 55 push %ebp 10cc61: 89 e5 mov %esp,%ebp 10cc63: 57 push %edi 10cc64: 56 push %esi 10cc65: 53 push %ebx 10cc66: 83 ec 20 sub $0x20,%esp 10cc69: 8b 45 0c mov 0xc(%ebp),%eax uint32_t search_count; Heap_Block *the_block; void *user_ptr = NULL; uint32_t const page_size = the_heap->page_size; 10cc6c: 8b 55 08 mov 0x8(%ebp),%edx 10cc6f: 8b 52 10 mov 0x10(%edx),%edx 10cc72: 89 55 dc mov %edx,-0x24(%ebp) 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; 10cc75: 8d 48 fc lea -0x4(%eax),%ecx 10cc78: 89 4d e0 mov %ecx,-0x20(%ebp) uint32_t const the_size = _Heap_Calc_block_size(size, page_size, the_heap->min_block_size); 10cc7b: 8b 7d 08 mov 0x8(%ebp),%edi 10cc7e: ff 77 14 pushl 0x14(%edi) 10cc81: 52 push %edx 10cc82: 50 push %eax 10cc83: e8 8c 04 00 00 call 10d114 <_Heap_Calc_block_size> 10cc88: 89 45 e4 mov %eax,-0x1c(%ebp) if(the_size == 0) 10cc8b: 83 c4 10 add $0x10,%esp 10cc8e: 85 c0 test %eax,%eax 10cc90: 0f 84 1a 01 00 00 je 10cdb0 <_Heap_Allocate_aligned+0x150><== NEVER TAKEN return NULL; if(alignment == 0) 10cc96: 8b 45 10 mov 0x10(%ebp),%eax 10cc99: 85 c0 test %eax,%eax 10cc9b: 0f 84 03 01 00 00 je 10cda4 <_Heap_Allocate_aligned+0x144> ) { return ( the_thread == _Thread_Heir ); } /** 10cca1: 8b 45 08 mov 0x8(%ebp),%eax 10cca4: 8b 48 08 mov 0x8(%eax),%ecx 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; 10cca7: 39 c8 cmp %ecx,%eax 10cca9: 0f 84 01 01 00 00 je 10cdb0 <_Heap_Allocate_aligned+0x150><== NEVER TAKEN 10ccaf: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) 10ccb6: eb 17 jmp 10cccf <_Heap_Allocate_aligned+0x6f> '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) { 10ccb8: 89 f2 mov %esi,%edx <== NOT EXECUTED aligned_user_addr = 0; } } } if(aligned_user_addr) { 10ccba: 85 ff test %edi,%edi 10ccbc: 75 7a jne 10cd38 <_Heap_Allocate_aligned+0xd8><== ALWAYS TAKEN 10ccbe: 66 90 xchg %ax,%ax /* 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) 10ccc0: 8b 49 08 mov 0x8(%ecx),%ecx 10ccc3: ff 45 f0 incl -0x10(%ebp) 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; 10ccc6: 39 4d 08 cmp %ecx,0x8(%ebp) 10ccc9: 0f 84 ed 00 00 00 je 10cdbc <_Heap_Allocate_aligned+0x15c> 10cccf: 8b 59 04 mov 0x4(%ecx),%ebx 10ccd2: 83 e3 fe and $0xfffffffe,%ebx 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. */ 10ccd5: 39 5d e4 cmp %ebx,-0x1c(%ebp) 10ccd8: 77 e6 ja 10ccc0 <_Heap_Allocate_aligned+0x60> _H_uptr_t user_addr; _H_uptr_t aligned_user_addr; _H_uptr_t const user_area = _H_p2u(_Heap_User_area(the_block)); 10ccda: 8d 71 08 lea 0x8(%ecx),%esi /* 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; 10ccdd: 8d 14 19 lea (%ecx,%ebx,1),%edx 10cce0: 89 55 e8 mov %edx,-0x18(%ebp) aligned_user_addr = block_end - end_to_user_offs; 10cce3: 89 d7 mov %edx,%edi 10cce5: 2b 7d e0 sub -0x20(%ebp),%edi RTEMS_INLINE_ROUTINE void _Thread_Dispatch_initialization( void ) { _Thread_Dispatch_disable_level = 1; } 10cce8: 89 f8 mov %edi,%eax 10ccea: 31 d2 xor %edx,%edx 10ccec: f7 75 10 divl 0x10(%ebp) 10ccef: 29 d7 sub %edx,%edi 10ccf1: 89 f8 mov %edi,%eax 10ccf3: 31 d2 xor %edx,%edx 10ccf5: f7 75 dc divl -0x24(%ebp) 10ccf8: 89 f8 mov %edi,%eax 10ccfa: 29 d0 sub %edx,%eax 10ccfc: 89 c2 mov %eax,%edx 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) { 10ccfe: 39 c6 cmp %eax,%esi 10cd00: 77 be ja 10ccc0 <_Heap_Allocate_aligned+0x60> /* 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) { 10cd02: 8b 45 08 mov 0x8(%ebp),%eax 10cd05: 8b 40 14 mov 0x14(%eax),%eax 10cd08: 89 45 ec mov %eax,-0x14(%ebp) 10cd0b: 89 d0 mov %edx,%eax 10cd0d: 29 f0 sub %esi,%eax 10cd0f: 3b 45 ec cmp -0x14(%ebp),%eax 10cd12: 73 a6 jae 10ccba <_Heap_Allocate_aligned+0x5a> '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) { 10cd14: 89 f8 mov %edi,%eax 10cd16: 29 f0 sub %esi,%eax 10cd18: 39 45 dc cmp %eax,-0x24(%ebp) 10cd1b: 77 9b ja 10ccb8 <_Heap_Allocate_aligned+0x58><== NEVER TAKEN RTEMS_INLINE_ROUTINE bool _Thread_Is_dispatching_enabled( void ) { return ( _Thread_Dispatch_disable_level == 0 ); } /** 10cd1d: 89 f0 mov %esi,%eax 10cd1f: 31 d2 xor %edx,%edx 10cd21: f7 75 10 divl 0x10(%ebp) * This function returns TRUE if dispatching is disabled, and FALSE 10cd24: 85 d2 test %edx,%edx 10cd26: 75 6c jne 10cd94 <_Heap_Allocate_aligned+0x134> 10cd28: 89 f0 mov %esi,%eax /* 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) { 10cd2a: 39 55 dc cmp %edx,-0x24(%ebp) 10cd2d: 76 91 jbe 10ccc0 <_Heap_Allocate_aligned+0x60> 10cd2f: 89 f2 mov %esi,%edx 10cd31: 89 c7 mov %eax,%edi aligned_user_addr = 0; } } } if(aligned_user_addr) { 10cd33: 85 ff test %edi,%edi 10cd35: 74 89 je 10ccc0 <_Heap_Allocate_aligned+0x60><== NEVER TAKEN 10cd37: 90 nop /* 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; 10cd38: 8b 75 e8 mov -0x18(%ebp),%esi 10cd3b: 83 c6 08 add $0x8,%esi 10cd3e: 29 d6 sub %edx,%esi 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; 10cd40: 89 da mov %ebx,%edx 10cd42: 29 f2 sub %esi,%edx _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) { 10cd44: 3b 55 ec cmp -0x14(%ebp),%edx 10cd47: 0f 82 87 00 00 00 jb 10cdd4 <_Heap_Allocate_aligned+0x174> /* Split the block so that lower part is still free, and upper part becomes used. */ the_block->size = the_rest | HEAP_PREV_USED; 10cd4d: 89 d0 mov %edx,%eax 10cd4f: 83 c8 01 or $0x1,%eax 10cd52: 89 41 04 mov %eax,0x4(%ecx) 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 ); 10cd55: 8d 04 11 lea (%ecx,%edx,1),%eax /** @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 10cd58: 89 c1 mov %eax,%ecx the_block = _Heap_Block_at(the_block, the_rest); the_block->prev_size = the_rest; 10cd5a: 89 10 mov %edx,(%eax) the_block->size = alloc_size; 10cd5c: 89 70 04 mov %esi,0x4(%eax) _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; 10cd5f: 83 4c 31 04 01 orl $0x1,0x4(%ecx,%esi,1) /* Update statistics */ stats->free_size -= alloc_size; 10cd64: 8b 55 08 mov 0x8(%ebp),%edx 10cd67: 8b 42 30 mov 0x30(%edx),%eax 10cd6a: 29 f0 sub %esi,%eax 10cd6c: 89 42 30 mov %eax,0x30(%edx) if(stats->min_free_size > stats->free_size) 10cd6f: 3b 42 34 cmp 0x34(%edx),%eax 10cd72: 73 03 jae 10cd77 <_Heap_Allocate_aligned+0x117> stats->min_free_size = stats->free_size; 10cd74: 89 42 34 mov %eax,0x34(%edx) stats->used_blocks += 1; 10cd77: 8b 4d 08 mov 0x8(%ebp),%ecx 10cd7a: ff 41 40 incl 0x40(%ecx) _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; 10cd7d: 8b 41 4c mov 0x4c(%ecx),%eax 10cd80: 8b 55 f0 mov -0x10(%ebp),%edx 10cd83: 8d 44 02 01 lea 0x1(%edx,%eax,1),%eax 10cd87: 89 41 4c mov %eax,0x4c(%ecx) stats->allocs += 1; 10cd8a: ff 41 48 incl 0x48(%ecx) check_result(the_heap, the_block, user_addr, aligned_user_addr, size); user_ptr = (void*)aligned_user_addr; 10cd8d: 89 f8 mov %edi,%eax 10cd8f: eb 2d jmp 10cdbe <_Heap_Allocate_aligned+0x15e> 10cd91: 8d 76 00 lea 0x0(%esi),%esi { return ( _Thread_Dispatch_disable_level == 0 ); } /** * This function returns TRUE if dispatching is disabled, and FALSE 10cd94: 8b 7d 10 mov 0x10(%ebp),%edi 10cd97: 8d 04 3e lea (%esi,%edi,1),%eax 10cd9a: 29 d0 sub %edx,%eax 10cd9c: 89 c2 mov %eax,%edx 10cd9e: 29 f2 sub %esi,%edx 10cda0: eb 88 jmp 10cd2a <_Heap_Allocate_aligned+0xca> 10cda2: 66 90 xchg %ax,%ax _Heap_Calc_block_size(size, page_size, the_heap->min_block_size); if(the_size == 0) return NULL; if(alignment == 0) 10cda4: c7 45 10 04 00 00 00 movl $0x4,0x10(%ebp) 10cdab: e9 f1 fe ff ff jmp 10cca1 <_Heap_Allocate_aligned+0x41> } } } if(stats->max_search < search_count) stats->max_search = search_count; 10cdb0: 31 c0 xor %eax,%eax return user_ptr; } 10cdb2: 8d 65 f4 lea -0xc(%ebp),%esp 10cdb5: 5b pop %ebx 10cdb6: 5e pop %esi 10cdb7: 5f pop %edi 10cdb8: c9 leave 10cdb9: c3 ret 10cdba: 66 90 xchg %ax,%ax 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; 10cdbc: 31 c0 xor %eax,%eax } } } } if(stats->max_search < search_count) 10cdbe: 8b 4d f0 mov -0x10(%ebp),%ecx 10cdc1: 8b 7d 08 mov 0x8(%ebp),%edi 10cdc4: 39 4f 44 cmp %ecx,0x44(%edi) 10cdc7: 73 e9 jae 10cdb2 <_Heap_Allocate_aligned+0x152> stats->max_search = search_count; 10cdc9: 89 4f 44 mov %ecx,0x44(%edi) return user_ptr; } 10cdcc: 8d 65 f4 lea -0xc(%ebp),%esp 10cdcf: 5b pop %ebx 10cdd0: 5e pop %esi 10cdd1: 5f pop %edi 10cdd2: c9 leave 10cdd3: c3 ret * This routine resets the current context of the calling thread * to that of its initial state. */ RTEMS_INLINE_ROUTINE void _Thread_Restart_self( void ) { 10cdd4: 8b 51 08 mov 0x8(%ecx),%edx #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) 10cdd7: 8b 41 0c mov 0xc(%ecx),%eax if ( _Thread_Executing->fp_context != NULL ) 10cdda: 89 50 08 mov %edx,0x8(%eax) _Context_Restore_fp( &_Thread_Executing->fp_context ); 10cddd: 89 42 0c mov %eax,0xc(%edx) /* 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; 10cde0: 8b 45 08 mov 0x8(%ebp),%eax 10cde3: ff 48 38 decl 0x38(%eax) 10cde6: 89 de mov %ebx,%esi 10cde8: e9 72 ff ff ff jmp 10cd5f <_Heap_Allocate_aligned+0xff> =============================================================================== 0010b49c <_Heap_Block_allocate>: uint32_t _Heap_Block_allocate( Heap_Control* the_heap, Heap_Block* the_block, uint32_t alloc_size ) { 10b49c: 55 push %ebp 10b49d: 89 e5 mov %esp,%ebp 10b49f: 57 push %edi 10b4a0: 56 push %esi 10b4a1: 53 push %ebx 10b4a2: 8b 75 0c mov 0xc(%ebp),%esi 10b4a5: 8b 7d 10 mov 0x10(%ebp),%edi 10b4a8: 8b 4e 04 mov 0x4(%esi),%ecx 10b4ab: 83 e1 fe and $0xfffffffe,%ecx 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; 10b4ae: 89 cb mov %ecx,%ebx 10b4b0: 29 fb sub %edi,%ebx _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) { 10b4b2: 8b 45 08 mov 0x8(%ebp),%eax 10b4b5: 3b 58 14 cmp 0x14(%eax),%ebx 10b4b8: 72 4a jb 10b504 <_Heap_Block_allocate+0x68> 10b4ba: 8d 14 3e lea (%esi,%edi,1),%edx * @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 */ 10b4bd: 8b 4e 08 mov 0x8(%esi),%ecx bool _Protected_heap_Get_block_size( 10b4c0: 8b 46 0c mov 0xc(%esi),%eax Heap_Control *the_heap, void *starting_address, size_t *size 10b4c3: 89 4a 08 mov %ecx,0x8(%edx) ); 10b4c6: 89 42 0c mov %eax,0xc(%edx) 10b4c9: 89 50 08 mov %edx,0x8(%eax) 10b4cc: 89 51 0c mov %edx,0xc(%ecx) 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; 10b4cf: 89 f8 mov %edi,%eax 10b4d1: 83 c8 01 or $0x1,%eax 10b4d4: 89 46 04 mov %eax,0x4(%esi) next_block->size = the_rest | HEAP_PREV_USED; 10b4d7: 89 d8 mov %ebx,%eax 10b4d9: 83 c8 01 or $0x1,%eax 10b4dc: 89 42 04 mov %eax,0x4(%edx) _Heap_Block_at(next_block, the_rest)->prev_size = the_rest; 10b4df: 89 1c 1a mov %ebx,(%edx,%ebx,1) 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; 10b4e2: 8b 55 08 mov 0x8(%ebp),%edx 10b4e5: 8b 42 30 mov 0x30(%edx),%eax 10b4e8: 29 f8 sub %edi,%eax 10b4ea: 89 42 30 mov %eax,0x30(%edx) if(stats->min_free_size > stats->free_size) 10b4ed: 3b 42 34 cmp 0x34(%edx),%eax 10b4f0: 73 03 jae 10b4f5 <_Heap_Block_allocate+0x59> stats->min_free_size = stats->free_size; 10b4f2: 89 42 34 mov %eax,0x34(%edx) stats->used_blocks += 1; 10b4f5: 8b 45 08 mov 0x8(%ebp),%eax 10b4f8: ff 40 40 incl 0x40(%eax) return alloc_size; } 10b4fb: 89 f8 mov %edi,%eax 10b4fd: 5b pop %ebx 10b4fe: 5e pop %esi 10b4ff: 5f pop %edi 10b500: c9 leave 10b501: c3 ret 10b502: 66 90 xchg %ax,%ax * 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 10b504: 8b 56 08 mov 0x8(%esi),%edx * @param[in] size is the amount of memory to allocate in bytes 10b507: 8b 46 0c mov 0xc(%esi),%eax * @param[in] alignment the required alignment 10b50a: 89 50 08 mov %edx,0x8(%eax) * @return NULL if unsuccessful and a pointer to the block if successful 10b50d: 89 42 0c mov %eax,0xc(%edx) /* 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; 10b510: 83 4c 0e 04 01 orl $0x1,0x4(%esi,%ecx,1) stats->free_blocks -= 1; 10b515: 8b 55 08 mov 0x8(%ebp),%edx 10b518: ff 4a 38 decl 0x38(%edx) 10b51b: 89 cf mov %ecx,%edi 10b51d: eb c3 jmp 10b4e2 <_Heap_Block_allocate+0x46> =============================================================================== 0010b468 <_Heap_Calc_block_size>: */ size_t _Heap_Calc_block_size( size_t size, uint32_t page_size, uint32_t min_size) { 10b468: 55 push %ebp 10b469: 89 e5 mov %esp,%ebp 10b46b: 53 push %ebx 10b46c: 83 ec 04 sub $0x4,%esp 10b46f: 8b 4d 08 mov 0x8(%ebp),%ecx uint32_t block_size = size + HEAP_BLOCK_USED_OVERHEAD; 10b472: 8d 59 04 lea 0x4(%ecx),%ebx * 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 10b475: 89 d8 mov %ebx,%eax 10b477: 31 d2 xor %edx,%edx 10b479: f7 75 0c divl 0xc(%ebp) */ 10b47c: 85 d2 test %edx,%edx 10b47e: 74 05 je 10b485 <_Heap_Calc_block_size+0x1d> 10b480: 03 5d 0c add 0xc(%ebp),%ebx 10b483: 29 d3 sub %edx,%ebx 10b485: 89 d8 mov %ebx,%eax 10b487: 3b 5d 10 cmp 0x10(%ebp),%ebx 10b48a: 73 03 jae 10b48f <_Heap_Calc_block_size+0x27> 10b48c: 8b 45 10 mov 0x10(%ebp),%eax _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; 10b48f: 39 c1 cmp %eax,%ecx 10b491: 72 02 jb 10b495 <_Heap_Calc_block_size+0x2d><== ALWAYS TAKEN 10b493: 31 c0 xor %eax,%eax } 10b495: 5a pop %edx 10b496: 5b pop %ebx 10b497: c9 leave 10b498: c3 ret =============================================================================== 00111460 <_Heap_Extend>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t *amount_extended ) { 111460: 55 push %ebp 111461: 89 e5 mov %esp,%ebp 111463: 56 push %esi 111464: 53 push %ebx 111465: 83 ec 10 sub $0x10,%esp 111468: 8b 4d 08 mov 0x8(%ebp),%ecx 11146b: 8b 45 0c mov 0xc(%ebp),%eax * 5. non-contiguous higher address (NOT SUPPORTED) * * As noted, this code only supports (4). */ if ( starting_address >= the_heap->begin && /* case 3 */ 11146e: 39 41 18 cmp %eax,0x18(%ecx) 111471: 76 15 jbe 111488 <_Heap_Extend+0x28> 111473: 8b 51 1c mov 0x1c(%ecx),%edx starting_address < the_heap->end ) return HEAP_EXTEND_ERROR; if ( starting_address != the_heap->end ) 111476: 39 d0 cmp %edx,%eax 111478: 74 22 je 11149c <_Heap_Extend+0x3c> 11147a: b8 02 00 00 00 mov $0x2,%eax stats->frees -= 1; /* Don't count subsequent call as actual free() */ _Heap_Free( the_heap, _Heap_User_area( old_final ) ); return HEAP_EXTEND_SUCCESSFUL; } 11147f: 8d 65 f8 lea -0x8(%ebp),%esp 111482: 5b pop %ebx 111483: 5e pop %esi 111484: c9 leave 111485: c3 ret 111486: 66 90 xchg %ax,%ax * 5. non-contiguous higher address (NOT SUPPORTED) * * As noted, this code only supports (4). */ if ( starting_address >= the_heap->begin && /* case 3 */ 111488: 8b 51 1c mov 0x1c(%ecx),%edx 11148b: 39 d0 cmp %edx,%eax 11148d: 73 e7 jae 111476 <_Heap_Extend+0x16> 11148f: b8 01 00 00 00 mov $0x1,%eax stats->frees -= 1; /* Don't count subsequent call as actual free() */ _Heap_Free( the_heap, _Heap_User_area( old_final ) ); return HEAP_EXTEND_SUCCESSFUL; } 111494: 8d 65 f8 lea -0x8(%ebp),%esp 111497: 5b pop %ebx 111498: 5e pop %esi 111499: c9 leave 11149a: c3 ret 11149b: 90 nop * 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; 11149c: 8b 59 24 mov 0x24(%ecx),%ebx 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 ); 11149f: 03 45 10 add 0x10(%ebp),%eax the_heap->end = _Addresses_Add_offset( the_heap->end, size ); 1114a2: 89 41 1c mov %eax,0x1c(%ecx) the_size = _Addresses_Subtract( the_heap->end, old_final ) - HEAP_OVERHEAD; 1114a5: 29 d8 sub %ebx,%eax 1114a7: 8d 70 f8 lea -0x8(%eax),%esi * 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) || \ 1114aa: 89 f0 mov %esi,%eax 1114ac: 31 d2 xor %edx,%edx 1114ae: f7 71 10 divl 0x10(%ecx) 1114b1: 29 d6 sub %edx,%esi 1114b3: 89 f2 mov %esi,%edx _Heap_Align_down( &the_size, the_heap->page_size ); *amount_extended = size; 1114b5: 8b 45 10 mov 0x10(%ebp),%eax 1114b8: 8b 75 14 mov 0x14(%ebp),%esi 1114bb: 89 06 mov %eax,(%esi) if( the_size < the_heap->min_block_size ) 1114bd: 39 51 14 cmp %edx,0x14(%ecx) 1114c0: 76 06 jbe 1114c8 <_Heap_Extend+0x68> <== ALWAYS TAKEN 1114c2: 31 c0 xor %eax,%eax 1114c4: eb b9 jmp 11147f <_Heap_Extend+0x1f> <== NOT EXECUTED 1114c6: 66 90 xchg %ax,%ax <== NOT EXECUTED return HEAP_EXTEND_SUCCESSFUL; old_final->size = the_size | (old_final->size & HEAP_PREV_USED); 1114c8: 8b 43 04 mov 0x4(%ebx),%eax 1114cb: 83 e0 01 and $0x1,%eax 1114ce: 09 d0 or %edx,%eax 1114d0: 89 43 04 mov %eax,0x4(%ebx) /** @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 1114d3: 8d 04 13 lea (%ebx,%edx,1),%eax new_final = _Heap_Block_at( old_final, the_size ); new_final->size = HEAP_PREV_USED; 1114d6: c7 40 04 01 00 00 00 movl $0x1,0x4(%eax) the_heap->final = new_final; 1114dd: 89 41 24 mov %eax,0x24(%ecx) stats->size += size; 1114e0: 8b 55 10 mov 0x10(%ebp),%edx 1114e3: 01 51 2c add %edx,0x2c(%ecx) stats->used_blocks += 1; 1114e6: ff 41 40 incl 0x40(%ecx) stats->frees -= 1; /* Don't count subsequent call as actual free() */ 1114e9: ff 49 50 decl 0x50(%ecx) _Heap_Free( the_heap, _Heap_User_area( old_final ) ); 1114ec: 83 ec 08 sub $0x8,%esp 1114ef: 8d 43 08 lea 0x8(%ebx),%eax 1114f2: 50 push %eax 1114f3: 51 push %ecx 1114f4: e8 8b b9 ff ff call 10ce84 <_Heap_Free> 1114f9: 31 c0 xor %eax,%eax 1114fb: 83 c4 10 add $0x10,%esp 1114fe: e9 7c ff ff ff jmp 11147f <_Heap_Extend+0x1f> =============================================================================== 0010f35c <_Heap_Free>: bool _Heap_Free( Heap_Control *the_heap, void *starting_address ) { 10f35c: 55 push %ebp 10f35d: 89 e5 mov %esp,%ebp 10f35f: 57 push %edi 10f360: 56 push %esi 10f361: 53 push %ebx 10f362: 83 ec 18 sub $0x18,%esp 10f365: 8b 7d 08 mov 0x8(%ebp),%edi 10f368: 8b 45 0c mov 0xc(%ebp),%eax uint32_t the_size; uint32_t next_size; Heap_Statistics *const stats = &the_heap->stats; bool next_is_free; if ( !_Addresses_Is_in_range( 10f36b: 8b 77 24 mov 0x24(%edi),%esi 10f36e: 8b 4f 20 mov 0x20(%edi),%ecx Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10f371: 39 c1 cmp %eax,%ecx 10f373: 77 04 ja 10f379 <_Heap_Free+0x1d> 10f375: 39 c6 cmp %eax,%esi 10f377: 73 0b jae 10f384 <_Heap_Free+0x28> <== ALWAYS TAKEN stats->used_blocks -= 1; stats->free_size += the_size; stats->frees += 1; return( TRUE ); 10f379: 31 c0 xor %eax,%eax } 10f37b: 83 c4 18 add $0x18,%esp 10f37e: 5b pop %ebx 10f37f: 5e pop %esi 10f380: 5f pop %edi 10f381: c9 leave 10f382: c3 ret 10f383: 90 nop 10f384: 8d 58 f8 lea -0x8(%eax),%ebx 10f387: 31 d2 xor %edx,%edx 10f389: f7 77 10 divl 0x10(%edi) 10f38c: 29 d3 sub %edx,%ebx Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10f38e: 39 d9 cmp %ebx,%ecx 10f390: 77 e7 ja 10f379 <_Heap_Free+0x1d> <== NEVER TAKEN 10f392: 39 de cmp %ebx,%esi 10f394: 72 e3 jb 10f379 <_Heap_Free+0x1d> <== NEVER TAKEN 10f396: 8b 43 04 mov 0x4(%ebx),%eax 10f399: 89 45 dc mov %eax,-0x24(%ebp) 10f39c: 83 e0 fe and $0xfffffffe,%eax 10f39f: 89 45 e8 mov %eax,-0x18(%ebp) 10f3a2: 01 d8 add %ebx,%eax 10f3a4: 89 45 e4 mov %eax,-0x1c(%ebp) Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10f3a7: 39 c1 cmp %eax,%ecx 10f3a9: 77 ce ja 10f379 <_Heap_Free+0x1d> <== NEVER TAKEN 10f3ab: 39 c6 cmp %eax,%esi 10f3ad: 72 ca jb 10f379 <_Heap_Free+0x1d> <== NEVER TAKEN 10f3af: 8b 50 04 mov 0x4(%eax),%edx 10f3b2: 89 55 e0 mov %edx,-0x20(%ebp) if ( !_Heap_Is_block_in( the_heap, next_block ) ) { _HAssert( FALSE ); return( FALSE ); } if ( !_Heap_Is_prev_used( next_block ) ) { 10f3b5: f6 c2 01 test $0x1,%dl 10f3b8: 74 bf je 10f379 <_Heap_Free+0x1d> <== NEVER TAKEN 10f3ba: 83 e2 fe and $0xfffffffe,%edx 10f3bd: 89 55 ec mov %edx,-0x14(%ebp) _HAssert( FALSE ); return( FALSE ); } next_size = _Heap_Block_size( next_block ); next_is_free = next_block < the_heap->final && 10f3c0: 39 c6 cmp %eax,%esi 10f3c2: 76 74 jbe 10f438 <_Heap_Free+0xdc> 10f3c4: 8b 55 e4 mov -0x1c(%ebp),%edx 10f3c7: 8b 45 ec mov -0x14(%ebp),%eax 10f3ca: 8b 44 02 04 mov 0x4(%edx,%eax,1),%eax 10f3ce: 83 f0 01 xor $0x1,%eax 10f3d1: 89 45 e0 mov %eax,-0x20(%ebp) 10f3d4: 8a 45 e0 mov -0x20(%ebp),%al 10f3d7: 83 e0 01 and $0x1,%eax !_Heap_Is_prev_used(_Heap_Block_at(next_block, next_size)); if ( !_Heap_Is_prev_used( the_block ) ) { 10f3da: f6 45 dc 01 testb $0x1,-0x24(%ebp) 10f3de: 75 5c jne 10f43c <_Heap_Free+0xe0> uint32_t const prev_size = the_block->prev_size; 10f3e0: 8b 13 mov (%ebx),%edx 10f3e2: 89 55 f0 mov %edx,-0x10(%ebp) 10f3e5: 29 d3 sub %edx,%ebx Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10f3e7: 39 d9 cmp %ebx,%ecx 10f3e9: 77 8e ja 10f379 <_Heap_Free+0x1d> <== NEVER TAKEN 10f3eb: 39 de cmp %ebx,%esi 10f3ed: 72 8a jb 10f379 <_Heap_Free+0x1d> <== NEVER TAKEN 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) ) { 10f3ef: f6 43 04 01 testb $0x1,0x4(%ebx) 10f3f3: 74 84 je 10f379 <_Heap_Free+0x1d> <== NEVER TAKEN _HAssert( FALSE ); return( FALSE ); } if ( next_is_free ) { /* coalesce both */ 10f3f5: 84 c0 test %al,%al 10f3f7: 0f 84 a0 00 00 00 je 10f49d <_Heap_Free+0x141> uint32_t const size = the_size + prev_size + next_size; 10f3fd: 8b 55 e8 mov -0x18(%ebp),%edx 10f400: 03 55 ec add -0x14(%ebp),%edx 10f403: 03 55 f0 add -0x10(%ebp),%edx * 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 10f406: 8b 75 e4 mov -0x1c(%ebp),%esi 10f409: 8b 4e 08 mov 0x8(%esi),%ecx * @param[in] size is the amount of memory to allocate in bytes 10f40c: 8b 46 0c mov 0xc(%esi),%eax * @param[in] alignment the required alignment 10f40f: 89 48 08 mov %ecx,0x8(%eax) * @return NULL if unsuccessful and a pointer to the block if successful 10f412: 89 41 0c mov %eax,0xc(%ecx) _Heap_Block_remove( next_block ); stats->free_blocks -= 1; 10f415: ff 4f 38 decl 0x38(%edi) prev_block->size = size | HEAP_PREV_USED; 10f418: 89 d0 mov %edx,%eax 10f41a: 83 c8 01 or $0x1,%eax 10f41d: 89 43 04 mov %eax,0x4(%ebx) next_block = _Heap_Block_at( prev_block, size ); _HAssert(!_Heap_Is_prev_used( next_block)); next_block->prev_size = size; 10f420: 89 14 13 mov %edx,(%ebx,%edx,1) 10f423: 90 nop stats->free_blocks += 1; if ( stats->max_free_blocks < stats->free_blocks ) stats->max_free_blocks = stats->free_blocks; } stats->used_blocks -= 1; 10f424: ff 4f 40 decl 0x40(%edi) stats->free_size += the_size; 10f427: 8b 75 e8 mov -0x18(%ebp),%esi 10f42a: 01 77 30 add %esi,0x30(%edi) stats->frees += 1; 10f42d: ff 47 50 incl 0x50(%edi) 10f430: b0 01 mov $0x1,%al 10f432: e9 44 ff ff ff jmp 10f37b <_Heap_Free+0x1f> 10f437: 90 nop _HAssert( FALSE ); return( FALSE ); } next_size = _Heap_Block_size( next_block ); next_is_free = next_block < the_heap->final && 10f438: 31 c0 xor %eax,%eax 10f43a: eb 9e jmp 10f3da <_Heap_Free+0x7e> 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 */ 10f43c: 84 c0 test %al,%al 10f43e: 74 28 je 10f468 <_Heap_Free+0x10c> uint32_t const size = the_size + next_size; 10f440: 8b 55 ec mov -0x14(%ebp),%edx 10f443: 03 55 e8 add -0x18(%ebp),%edx * @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 */ 10f446: 8b 75 e4 mov -0x1c(%ebp),%esi 10f449: 8b 4e 08 mov 0x8(%esi),%ecx bool _Protected_heap_Get_block_size( 10f44c: 8b 46 0c mov 0xc(%esi),%eax Heap_Control *the_heap, void *starting_address, size_t *size 10f44f: 89 4b 08 mov %ecx,0x8(%ebx) ); 10f452: 89 43 0c mov %eax,0xc(%ebx) 10f455: 89 58 08 mov %ebx,0x8(%eax) 10f458: 89 59 0c mov %ebx,0xc(%ecx) _Heap_Block_replace( next_block, the_block ); the_block->size = size | HEAP_PREV_USED; 10f45b: 89 d0 mov %edx,%eax 10f45d: 83 c8 01 or $0x1,%eax 10f460: 89 43 04 mov %eax,0x4(%ebx) next_block = _Heap_Block_at( the_block, size ); next_block->prev_size = size; 10f463: 89 14 13 mov %edx,(%ebx,%edx,1) 10f466: eb bc jmp 10f424 <_Heap_Free+0xc8> bool _Protected_heap_Resize_block( Heap_Control *the_heap, void *starting_address, size_t size ); 10f468: 8b 47 08 mov 0x8(%edi),%eax /** 10f46b: 89 43 08 mov %eax,0x8(%ebx) * This routine returns the block of memory which begins 10f46e: 89 7b 0c mov %edi,0xc(%ebx) * at @a starting_address to @a the_heap. Any coalescing which is 10f471: 89 5f 08 mov %ebx,0x8(%edi) 10f474: 89 58 0c mov %ebx,0xc(%eax) } 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; 10f477: 8b 45 e8 mov -0x18(%ebp),%eax 10f47a: 83 c8 01 or $0x1,%eax 10f47d: 89 43 04 mov %eax,0x4(%ebx) next_block->size &= ~HEAP_PREV_USED; 10f480: 8b 45 e4 mov -0x1c(%ebp),%eax 10f483: 83 60 04 fe andl $0xfffffffe,0x4(%eax) next_block->prev_size = the_size; 10f487: 8b 55 e8 mov -0x18(%ebp),%edx 10f48a: 89 10 mov %edx,(%eax) stats->free_blocks += 1; 10f48c: 8b 47 38 mov 0x38(%edi),%eax 10f48f: 40 inc %eax 10f490: 89 47 38 mov %eax,0x38(%edi) if ( stats->max_free_blocks < stats->free_blocks ) 10f493: 3b 47 3c cmp 0x3c(%edi),%eax 10f496: 76 8c jbe 10f424 <_Heap_Free+0xc8> stats->max_free_blocks = stats->free_blocks; 10f498: 89 47 3c mov %eax,0x3c(%edi) 10f49b: eb 87 jmp 10f424 <_Heap_Free+0xc8> 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; 10f49d: 8b 55 e8 mov -0x18(%ebp),%edx 10f4a0: 03 55 f0 add -0x10(%ebp),%edx prev_block->size = size | HEAP_PREV_USED; 10f4a3: 89 d0 mov %edx,%eax 10f4a5: 83 c8 01 or $0x1,%eax 10f4a8: 89 43 04 mov %eax,0x4(%ebx) next_block->size &= ~HEAP_PREV_USED; 10f4ab: 8b 45 e4 mov -0x1c(%ebp),%eax 10f4ae: 83 60 04 fe andl $0xfffffffe,0x4(%eax) next_block->prev_size = size; 10f4b2: 89 10 mov %edx,(%eax) 10f4b4: e9 6b ff ff ff jmp 10f424 <_Heap_Free+0xc8> =============================================================================== 00111504 <_Heap_Get_free_information>: void _Heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info ) { 111504: 55 push %ebp 111505: 89 e5 mov %esp,%ebp 111507: 53 push %ebx 111508: 8b 5d 08 mov 0x8(%ebp),%ebx 11150b: 8b 4d 0c mov 0xc(%ebp),%ecx Heap_Block *the_block; Heap_Block *const tail = _Heap_Tail(the_heap); info->number = 0; 11150e: c7 01 00 00 00 00 movl $0x0,(%ecx) info->largest = 0; 111514: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) info->total = 0; 11151b: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) ) { return ( the_thread == _Thread_Heir ); } /** 111522: 8b 53 08 mov 0x8(%ebx),%edx for(the_block = _Heap_First(the_heap); the_block != tail; 111525: 39 d3 cmp %edx,%ebx 111527: 74 1d je 111546 <_Heap_Get_free_information+0x42><== NEVER TAKEN 111529: 8d 76 00 lea 0x0(%esi),%esi 11152c: 8b 42 04 mov 0x4(%edx),%eax 11152f: 83 e0 fe and $0xfffffffe,%eax 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++; 111532: ff 01 incl (%ecx) info->total += the_size; 111534: 01 41 08 add %eax,0x8(%ecx) if ( info->largest < the_size ) 111537: 39 41 04 cmp %eax,0x4(%ecx) 11153a: 73 03 jae 11153f <_Heap_Get_free_information+0x3b><== NEVER TAKEN info->largest = the_size; 11153c: 89 41 04 mov %eax,0x4(%ecx) info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; the_block = the_block->next) 11153f: 8b 52 08 mov 0x8(%edx),%edx info->number = 0; info->largest = 0; info->total = 0; for(the_block = _Heap_First(the_heap); the_block != tail; 111542: 39 d3 cmp %edx,%ebx 111544: 75 e6 jne 11152c <_Heap_Get_free_information+0x28> info->number++; info->total += the_size; if ( info->largest < the_size ) info->largest = the_size; } } 111546: 5b pop %ebx 111547: c9 leave 111548: c3 ret =============================================================================== 0011154c <_Heap_Get_information>: Heap_Get_information_status _Heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 11154c: 55 push %ebp 11154d: 89 e5 mov %esp,%ebp 11154f: 56 push %esi 111550: 53 push %ebx 111551: 8b 45 08 mov 0x8(%ebp),%eax 111554: 8b 4d 0c mov 0xc(%ebp),%ecx Heap_Block *the_block = the_heap->start; 111557: 8b 50 20 mov 0x20(%eax),%edx Heap_Block *const end = the_heap->final; 11155a: 8b 70 24 mov 0x24(%eax),%esi _HAssert(the_block->prev_size == HEAP_PREV_USED); _HAssert(_Heap_Is_prev_used(the_block)); the_info->Free.number = 0; 11155d: c7 01 00 00 00 00 movl $0x0,(%ecx) the_info->Free.total = 0; 111563: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) the_info->Free.largest = 0; 11156a: c7 41 04 00 00 00 00 movl $0x0,0x4(%ecx) the_info->Used.number = 0; 111571: c7 41 0c 00 00 00 00 movl $0x0,0xc(%ecx) the_info->Used.total = 0; 111578: c7 41 14 00 00 00 00 movl $0x0,0x14(%ecx) the_info->Used.largest = 0; 11157f: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx) while ( the_block != end ) { 111586: 39 f2 cmp %esi,%edx 111588: 74 42 je 1115cc <_Heap_Get_information+0x80><== NEVER TAKEN 11158a: 8b 5a 04 mov 0x4(%edx),%ebx 11158d: eb 13 jmp 1115a2 <_Heap_Get_information+0x56> 11158f: 90 nop 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++; 111590: ff 41 0c incl 0xc(%ecx) the_info->Used.total += the_size; 111593: 01 41 14 add %eax,0x14(%ecx) if ( the_info->Used.largest < the_size ) 111596: 39 41 10 cmp %eax,0x10(%ecx) 111599: 73 03 jae 11159e <_Heap_Get_information+0x52> the_info->Used.largest = the_size; 11159b: 89 41 10 mov %eax,0x10(%ecx) the_info->Free.largest = 0; the_info->Used.number = 0; the_info->Used.total = 0; the_info->Used.largest = 0; while ( the_block != end ) { 11159e: 39 d6 cmp %edx,%esi 1115a0: 74 2a je 1115cc <_Heap_Get_information+0x80> 1115a2: 89 d8 mov %ebx,%eax 1115a4: 83 e0 fe and $0xfffffffe,%eax /** @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 1115a7: 01 c2 add %eax,%edx 1115a9: 8b 5a 04 mov 0x4(%edx),%ebx 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) ) { 1115ac: f6 c3 01 test $0x1,%bl 1115af: 75 df jne 111590 <_Heap_Get_information+0x44> 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++; 1115b1: ff 01 incl (%ecx) the_info->Free.total += the_size; 1115b3: 01 41 08 add %eax,0x8(%ecx) if ( the_info->Free.largest < the_size ) 1115b6: 39 41 04 cmp %eax,0x4(%ecx) 1115b9: 73 03 jae 1115be <_Heap_Get_information+0x72><== NEVER TAKEN the_info->Free.largest = the_size; 1115bb: 89 41 04 mov %eax,0x4(%ecx) if ( the_size != next_block->prev_size ) 1115be: 39 02 cmp %eax,(%edx) 1115c0: 74 dc je 11159e <_Heap_Get_information+0x52><== ALWAYS TAKEN 1115c2: 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; } 1115c7: 5b pop %ebx <== NOT EXECUTED 1115c8: 5e pop %esi <== NOT EXECUTED 1115c9: c9 leave <== NOT EXECUTED 1115ca: c3 ret <== NOT EXECUTED 1115cb: 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; 1115cc: 83 41 14 08 addl $0x8,0x14(%ecx) 1115d0: 31 c0 xor %eax,%eax return HEAP_GET_INFORMATION_SUCCESSFUL; } 1115d2: 5b pop %ebx 1115d3: 5e pop %esi 1115d4: c9 leave 1115d5: c3 ret =============================================================================== 0010b338 <_Heap_Initialize>: Heap_Control *the_heap, void *starting_address, size_t size, uint32_t page_size ) { 10b338: 55 push %ebp 10b339: 89 e5 mov %esp,%ebp 10b33b: 57 push %edi 10b33c: 56 push %esi 10b33d: 53 push %ebx 10b33e: 83 ec 08 sub $0x8,%esp 10b341: 8b 7d 08 mov 0x8(%ebp),%edi 10b344: 8b 4d 14 mov 0x14(%ebp),%ecx _H_uptr_t start; _H_uptr_t aligned_start; uint32_t overhead; Heap_Statistics *const stats = &the_heap->stats; if (page_size == 0) 10b347: 85 c9 test %ecx,%ecx 10b349: 0f 85 fd 00 00 00 jne 10b44c <_Heap_Initialize+0x114> 10b34f: b1 04 mov $0x4,%cl 10b351: 31 f6 xor %esi,%esi /* 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; 10b353: 8b 5d 0c mov 0xc(%ebp),%ebx 10b356: 83 c3 08 add $0x8,%ebx 10b359: 89 d8 mov %ebx,%eax 10b35b: 31 d2 xor %edx,%edx 10b35d: f7 f1 div %ecx 10b35f: 85 d2 test %edx,%edx 10b361: 74 05 je 10b368 <_Heap_Initialize+0x30> 10b363: 8d 1c 19 lea (%ecx,%ebx,1),%ebx 10b366: 29 d3 sub %edx,%ebx _Heap_Align_up_uptr ( &aligned_start, page_size ); aligned_start -= HEAP_BLOCK_USER_OFFSET; 10b368: 83 eb 08 sub $0x8,%ebx * * @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 */ 10b36b: 85 f6 test %esi,%esi 10b36d: 0f 85 cd 00 00 00 jne 10b440 <_Heap_Initialize+0x108> 10b373: b8 10 00 00 00 mov $0x10,%eax 10b378: 89 47 14 mov %eax,0x14(%edi) /* 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); 10b37b: 89 d8 mov %ebx,%eax 10b37d: 2b 45 0c sub 0xc(%ebp),%eax 10b380: 83 c0 08 add $0x8,%eax if ( size < overhead ) 10b383: 3b 45 10 cmp 0x10(%ebp),%eax 10b386: 0f 87 a8 00 00 00 ja 10b434 <_Heap_Initialize+0xfc> <== NEVER TAKEN return 0; /* Too small area for the heap */ the_size = size - overhead; 10b38c: 8b 75 10 mov 0x10(%ebp),%esi 10b38f: 29 c6 sub %eax,%esi * * @return free block information filled in. */ bool _Protected_heap_Get_free_information( Heap_Control *the_heap, Heap_Information *info 10b391: 89 f0 mov %esi,%eax 10b393: 31 d2 xor %edx,%edx 10b395: f7 f1 div %ecx _Heap_Align_down ( &the_size, page_size ); if ( the_size == 0 ) 10b397: 29 d6 sub %edx,%esi 10b399: 0f 84 95 00 00 00 je 10b434 <_Heap_Initialize+0xfc> return 0; /* Too small area for the heap */ the_heap->page_size = page_size; 10b39f: 89 4f 10 mov %ecx,0x10(%edi) the_heap->begin = starting_address; 10b3a2: 8b 45 0c mov 0xc(%ebp),%eax 10b3a5: 89 47 18 mov %eax,0x18(%edi) the_heap->end = starting_address + size; 10b3a8: 8b 45 0c mov 0xc(%ebp),%eax 10b3ab: 03 45 10 add 0x10(%ebp),%eax 10b3ae: 89 47 1c mov %eax,0x1c(%edi) the_block = (Heap_Block *) aligned_start; the_block->prev_size = page_size; 10b3b1: 89 0b mov %ecx,(%ebx) the_block->size = the_size | HEAP_PREV_USED; 10b3b3: 89 f0 mov %esi,%eax 10b3b5: 83 c8 01 or $0x1,%eax 10b3b8: 89 43 04 mov %eax,0x4(%ebx) the_block->next = _Heap_Tail( the_heap ); 10b3bb: 89 7b 08 mov %edi,0x8(%ebx) the_block->prev = _Heap_Head( the_heap ); 10b3be: 89 7b 0c mov %edi,0xc(%ebx) _Heap_Head(the_heap)->next = the_block; 10b3c1: 89 5f 08 mov %ebx,0x8(%edi) _Heap_Tail(the_heap)->prev = the_block; 10b3c4: 89 5f 0c mov %ebx,0xc(%edi) the_heap->start = the_block; 10b3c7: 89 5f 20 mov %ebx,0x20(%edi) * @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 10b3ca: 8d 04 33 lea (%ebx,%esi,1),%eax _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 */ 10b3cd: 89 47 24 mov %eax,0x24(%edi) the_block->prev_size = the_size; /* Previous block is free */ 10b3d0: 89 30 mov %esi,(%eax) the_block->size = page_size; 10b3d2: 89 48 04 mov %ecx,0x4(%eax) stats->size = size; 10b3d5: 8b 45 10 mov 0x10(%ebp),%eax 10b3d8: 89 47 2c mov %eax,0x2c(%edi) stats->free_size = the_size; 10b3db: 89 77 30 mov %esi,0x30(%edi) stats->min_free_size = the_size; 10b3de: 89 77 34 mov %esi,0x34(%edi) stats->free_blocks = 1; 10b3e1: c7 47 38 01 00 00 00 movl $0x1,0x38(%edi) stats->max_free_blocks = 1; 10b3e8: c7 47 3c 01 00 00 00 movl $0x1,0x3c(%edi) stats->used_blocks = 0; 10b3ef: c7 47 40 00 00 00 00 movl $0x0,0x40(%edi) stats->max_search = 0; 10b3f6: c7 47 44 00 00 00 00 movl $0x0,0x44(%edi) stats->allocs = 0; 10b3fd: c7 47 48 00 00 00 00 movl $0x0,0x48(%edi) stats->searches = 0; 10b404: c7 47 4c 00 00 00 00 movl $0x0,0x4c(%edi) stats->frees = 0; 10b40b: c7 47 50 00 00 00 00 movl $0x0,0x50(%edi) stats->resizes = 0; 10b412: c7 47 54 00 00 00 00 movl $0x0,0x54(%edi) stats->instance = instance++; 10b419: a1 c0 e3 11 00 mov 0x11e3c0,%eax 10b41e: 89 47 28 mov %eax,0x28(%edi) 10b421: 40 inc %eax 10b422: a3 c0 e3 11 00 mov %eax,0x11e3c0 return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 10b427: 8d 46 fc lea -0x4(%esi),%eax } 10b42a: 83 c4 08 add $0x8,%esp 10b42d: 5b pop %ebx 10b42e: 5e pop %esi 10b42f: 5f pop %edi 10b430: c9 leave 10b431: c3 ret 10b432: 66 90 xchg %ax,%ax stats->searches = 0; stats->frees = 0; stats->resizes = 0; stats->instance = instance++; return ( the_size - HEAP_BLOCK_USED_OVERHEAD ); 10b434: 31 c0 xor %eax,%eax } 10b436: 83 c4 08 add $0x8,%esp 10b439: 5b pop %ebx 10b43a: 5e pop %esi 10b43b: 5f pop %edi 10b43c: c9 leave 10b43d: c3 ret 10b43e: 66 90 xchg %ax,%ax * * @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 */ 10b440: 8d 41 10 lea 0x10(%ecx),%eax 10b443: 29 f0 sub %esi,%eax 10b445: e9 2e ff ff ff jmp 10b378 <_Heap_Initialize+0x40> 10b44a: 66 90 xchg %ax,%ax 10b44c: 89 c8 mov %ecx,%eax 10b44e: 83 e0 03 and $0x3,%eax 10b451: 74 05 je 10b458 <_Heap_Initialize+0x120> 10b453: 83 c1 04 add $0x4,%ecx 10b456: 29 c1 sub %eax,%ecx 10b458: b8 10 00 00 00 mov $0x10,%eax 10b45d: 31 d2 xor %edx,%edx 10b45f: f7 f1 div %ecx 10b461: 89 d6 mov %edx,%esi 10b463: e9 eb fe ff ff jmp 10b353 <_Heap_Initialize+0x1b> =============================================================================== 00116ac8 <_Heap_Resize_block>: void *starting_address, size_t size, uint32_t *old_mem_size, uint32_t *avail_mem_size ) { 116ac8: 55 push %ebp 116ac9: 89 e5 mov %esp,%ebp 116acb: 57 push %edi 116acc: 56 push %esi 116acd: 53 push %ebx 116ace: 83 ec 3c sub $0x3c,%esp 116ad1: 8b 75 08 mov 0x8(%ebp),%esi 116ad4: 8b 4d 0c mov 0xc(%ebp),%ecx 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; 116ad7: 8b 46 14 mov 0x14(%esi),%eax 116ada: 89 45 e0 mov %eax,-0x20(%ebp) uint32_t const page_size = the_heap->page_size; 116add: 8b 56 10 mov 0x10(%esi),%edx 116ae0: 89 55 e4 mov %edx,-0x1c(%ebp) *old_mem_size = 0; 116ae3: 8b 7d 14 mov 0x14(%ebp),%edi 116ae6: c7 07 00 00 00 00 movl $0x0,(%edi) *avail_mem_size = 0; 116aec: 8b 45 18 mov 0x18(%ebp),%eax 116aef: c7 00 00 00 00 00 movl $0x0,(%eax) 116af5: 8d 59 f8 lea -0x8(%ecx),%ebx 116af8: 89 c8 mov %ecx,%eax 116afa: 31 d2 xor %edx,%edx 116afc: f7 76 10 divl 0x10(%esi) 116aff: 29 d3 sub %edx,%ebx 116b01: 8b 56 24 mov 0x24(%esi),%edx 116b04: 8b 46 20 mov 0x20(%esi),%eax /* end of include file */ 116b07: 39 c3 cmp %eax,%ebx 116b09: 72 04 jb 116b0f <_Heap_Resize_block+0x47><== NEVER TAKEN 116b0b: 39 d3 cmp %edx,%ebx 116b0d: 76 0d jbe 116b1c <_Heap_Resize_block+0x54> } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 116b0f: b8 02 00 00 00 mov $0x2,%eax } 116b14: 8d 65 f4 lea -0xc(%ebp),%esp 116b17: 5b pop %ebx 116b18: 5e pop %esi 116b19: 5f pop %edi 116b1a: c9 leave 116b1b: c3 ret _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; 116b1c: 8b 7b 04 mov 0x4(%ebx),%edi 116b1f: 89 7d cc mov %edi,-0x34(%ebp) 116b22: 83 e7 fe and $0xfffffffe,%edi 116b25: 89 7d d8 mov %edi,-0x28(%ebp) 116b28: 01 df add %ebx,%edi 116b2a: 89 7d c0 mov %edi,-0x40(%ebp) /* end of include file */ 116b2d: 39 f8 cmp %edi,%eax 116b2f: 77 de ja 116b0f <_Heap_Resize_block+0x47><== NEVER TAKEN 116b31: 39 fa cmp %edi,%edx 116b33: 72 da jb 116b0f <_Heap_Resize_block+0x47><== NEVER TAKEN 116b35: 8b 47 04 mov 0x4(%edi),%eax 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) || 116b38: a8 01 test $0x1,%al 116b3a: 74 d3 je 116b0f <_Heap_Resize_block+0x47><== NEVER TAKEN 116b3c: 83 e0 fe and $0xfffffffe,%eax 116b3f: 89 45 d0 mov %eax,-0x30(%ebp) 116b42: 01 f8 add %edi,%eax 116b44: 89 45 d4 mov %eax,-0x2c(%ebp) !_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) || 116b47: 39 fa cmp %edi,%edx 116b49: 0f 84 11 01 00 00 je 116c60 <_Heap_Resize_block+0x198><== NEVER TAKEN 116b4f: 8b 55 d4 mov -0x2c(%ebp),%edx 116b52: 8b 42 04 mov 0x4(%edx),%eax 116b55: 83 e0 01 and $0x1,%eax 116b58: 88 45 f3 mov %al,-0xd(%ebp) _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; 116b5b: 8b 7d cc mov -0x34(%ebp),%edi 116b5e: 83 e7 01 and $0x1,%edi 116b61: 89 7d dc mov %edi,-0x24(%ebp) 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) 116b64: 8b 45 c0 mov -0x40(%ebp),%eax 116b67: 29 c8 sub %ecx,%eax 116b69: 83 c0 04 add $0x4,%eax + HEAP_BLOCK_HEADER_OFFSET; *old_mem_size = old_user_size; 116b6c: 8b 55 14 mov 0x14(%ebp),%edx 116b6f: 89 02 mov %eax,(%edx) if (size > old_user_size) { 116b71: 3b 45 10 cmp 0x10(%ebp),%eax 116b74: 73 3a jae 116bb0 <_Heap_Resize_block+0xe8> /* 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 */ 116b76: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) 116b7a: 75 29 jne 116ba5 <_Heap_Resize_block+0xdd> return HEAP_RESIZE_UNSATISFIED; else { uint32_t add_block_size = size - old_user_size; 116b7c: 8b 4d 10 mov 0x10(%ebp),%ecx 116b7f: 29 c1 sub %eax,%ecx 116b81: 89 c8 mov %ecx,%eax 116b83: 31 d2 xor %edx,%edx 116b85: f7 75 e4 divl -0x1c(%ebp) 116b88: 85 d2 test %edx,%edx 116b8a: 74 05 je 116b91 <_Heap_Resize_block+0xc9><== NEVER TAKEN 116b8c: 03 4d e4 add -0x1c(%ebp),%ecx 116b8f: 29 d1 sub %edx,%ecx 116b91: 89 c8 mov %ecx,%eax 116b93: 3b 4d e0 cmp -0x20(%ebp),%ecx 116b96: 0f 82 a0 00 00 00 jb 116c3c <_Heap_Resize_block+0x174><== ALWAYS TAKEN _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) 116b9c: 39 45 d0 cmp %eax,-0x30(%ebp) 116b9f: 0f 83 9f 00 00 00 jae 116c44 <_Heap_Resize_block+0x17c><== ALWAYS TAKEN } } } ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; 116ba5: b8 01 00 00 00 mov $0x1,%eax 116baa: e9 65 ff ff ff jmp 116b14 <_Heap_Resize_block+0x4c> 116baf: 90 nop --stats->used_blocks; } } else { /* Calculate how much memory we could free */ uint32_t free_block_size = old_user_size - size; 116bb0: 89 c1 mov %eax,%ecx 116bb2: 2b 4d 10 sub 0x10(%ebp),%ecx 116bb5: 89 c8 mov %ecx,%eax 116bb7: 31 d2 xor %edx,%edx 116bb9: f7 75 e4 divl -0x1c(%ebp) _Heap_Align_down(&free_block_size, page_size); if (free_block_size > 0) { 116bbc: 29 d1 sub %edx,%ecx 116bbe: 89 4d e8 mov %ecx,-0x18(%ebp) 116bc1: 74 69 je 116c2c <_Heap_Resize_block+0x164> /* 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; 116bc3: 8b 55 d8 mov -0x28(%ebp),%edx 116bc6: 29 ca sub %ecx,%edx 116bc8: 89 55 ec mov %edx,-0x14(%ebp) if (new_block_size < min_block_size) { 116bcb: 39 55 e0 cmp %edx,-0x20(%ebp) 116bce: 76 0d jbe 116bdd <_Heap_Resize_block+0x115> uint32_t delta = min_block_size - new_block_size; 116bd0: 8b 45 e0 mov -0x20(%ebp),%eax 116bd3: 29 d0 sub %edx,%eax _HAssert(free_block_size >= delta); free_block_size -= delta; if (free_block_size == 0) { 116bd5: 29 45 e8 sub %eax,-0x18(%ebp) 116bd8: 74 52 je 116c2c <_Heap_Resize_block+0x164><== ALWAYS TAKEN ++stats->resizes; return HEAP_RESIZE_SUCCESSFUL; } new_block_size += delta; 116bda: 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) { 116bdd: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) 116be1: 0f 85 85 00 00 00 jne 116c6c <_Heap_Resize_block+0x1a4><== NEVER TAKEN 116be7: 8b 7d ec mov -0x14(%ebp),%edi 116bea: 8d 14 3b lea (%ebx,%edi,1),%edx /* 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; 116bed: 8b 4d e8 mov -0x18(%ebp),%ecx 116bf0: 03 4d d0 add -0x30(%ebp),%ecx _HAssert(_Heap_Is_block_in(the_heap, next_next_block)); the_block->size = new_block_size | prev_used_flag; 116bf3: 8b 45 dc mov -0x24(%ebp),%eax 116bf6: 09 c7 or %eax,%edi 116bf8: 89 7b 04 mov %edi,0x4(%ebx) new_next_block->size = new_next_block_size | HEAP_PREV_USED; 116bfb: 89 c8 mov %ecx,%eax 116bfd: 83 c8 01 or $0x1,%eax 116c00: 89 42 04 mov %eax,0x4(%edx) next_next_block->prev_size = new_next_block_size; 116c03: 8b 7d d4 mov -0x2c(%ebp),%edi 116c06: 89 0f mov %ecx,(%edi) { return (state == SYSTEM_STATE_FAILED); } /**@}*/ 116c08: 8b 45 c0 mov -0x40(%ebp),%eax 116c0b: 8b 58 08 mov 0x8(%eax),%ebx #endif 116c0e: 8b 40 0c mov 0xc(%eax),%eax /* end of include file */ 116c11: 89 5a 08 mov %ebx,0x8(%edx) 116c14: 89 42 0c mov %eax,0xc(%edx) 116c17: 89 50 08 mov %edx,0x8(%eax) 116c1a: 89 53 0c mov %edx,0xc(%ebx) _Heap_Block_replace(next_block, new_next_block); the_heap->stats.free_size += free_block_size; 116c1d: 8b 45 e8 mov -0x18(%ebp),%eax 116c20: 01 46 30 add %eax,0x30(%esi) *avail_mem_size = new_next_block_size - HEAP_BLOCK_USED_OVERHEAD; 116c23: 83 e9 04 sub $0x4,%ecx 116c26: 8b 55 18 mov 0x18(%ebp),%edx 116c29: 89 0a mov %ecx,(%edx) 116c2b: 90 nop *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; } } } ++stats->resizes; 116c2c: ff 46 54 incl 0x54(%esi) 116c2f: 31 c0 xor %eax,%eax return HEAP_RESIZE_SUCCESSFUL; } 116c31: 8d 65 f4 lea -0xc(%ebp),%esp 116c34: 5b pop %ebx 116c35: 5e pop %esi 116c36: 5f pop %edi 116c37: c9 leave 116c38: c3 ret 116c39: 8d 76 00 lea 0x0(%esi),%esi 116c3c: 8b 45 e0 mov -0x20(%ebp),%eax 116c3f: e9 58 ff ff ff jmp 116b9c <_Heap_Resize_block+0xd4> _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 = 116c44: 52 push %edx 116c45: 50 push %eax 116c46: ff 75 c0 pushl -0x40(%ebp) 116c49: 56 push %esi 116c4a: e8 4d 48 ff ff call 10b49c <_Heap_Block_allocate> _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; 116c4f: 03 45 d8 add -0x28(%ebp),%eax 116c52: 0b 45 dc or -0x24(%ebp),%eax 116c55: 89 43 04 mov %eax,0x4(%ebx) --stats->used_blocks; 116c58: ff 4e 40 decl 0x40(%esi) 116c5b: 83 c4 10 add $0x10,%esp 116c5e: eb cc jmp 116c2c <_Heap_Resize_block+0x164> !_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) || 116c60: c6 45 f3 01 movb $0x1,-0xd(%ebp) <== NOT EXECUTED 116c64: e9 f2 fe ff ff jmp 116b5b <_Heap_Resize_block+0x93><== NOT EXECUTED 116c69: 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) { 116c6c: 8b 7d e8 mov -0x18(%ebp),%edi <== NOT EXECUTED 116c6f: 39 7d e0 cmp %edi,-0x20(%ebp) <== NOT EXECUTED 116c72: 77 b8 ja 116c2c <_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; 116c74: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 116c77: 09 45 dc or %eax,-0x24(%ebp) <== NOT EXECUTED 116c7a: 8b 55 dc mov -0x24(%ebp),%edx <== NOT EXECUTED 116c7d: 89 53 04 mov %edx,0x4(%ebx) <== NOT EXECUTED 116c80: 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; 116c83: 8b 55 e8 mov -0x18(%ebp),%edx <== NOT EXECUTED 116c86: 83 ca 01 or $0x1,%edx <== NOT EXECUTED 116c89: 89 50 04 mov %edx,0x4(%eax) <== NOT EXECUTED ++stats->used_blocks; /* We have created used block */ 116c8c: ff 46 40 incl 0x40(%esi) <== NOT EXECUTED --stats->frees; /* Don't count next call in stats */ 116c8f: ff 4e 50 decl 0x50(%esi) <== NOT EXECUTED _Heap_Free(the_heap, _Heap_User_area(next_block)); 116c92: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 116c95: 83 c0 08 add $0x8,%eax <== NOT EXECUTED 116c98: 50 push %eax <== NOT EXECUTED 116c99: 56 push %esi <== NOT EXECUTED 116c9a: e8 bd 86 ff ff call 10f35c <_Heap_Free> <== NOT EXECUTED *avail_mem_size = free_block_size - HEAP_BLOCK_USED_OVERHEAD; 116c9f: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 116ca2: 83 e8 04 sub $0x4,%eax <== NOT EXECUTED 116ca5: 8b 55 18 mov 0x18(%ebp),%edx <== NOT EXECUTED 116ca8: 89 02 mov %eax,(%edx) <== NOT EXECUTED 116caa: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116cad: e9 7a ff ff ff jmp 116c2c <_Heap_Resize_block+0x164><== NOT EXECUTED =============================================================================== 00116cb4 <_Heap_Size_of_user_area>: bool _Heap_Size_of_user_area( Heap_Control *the_heap, void *starting_address, size_t *size ) { 116cb4: 55 push %ebp 116cb5: 89 e5 mov %esp,%ebp 116cb7: 57 push %edi 116cb8: 56 push %esi 116cb9: 53 push %ebx 116cba: 83 ec 0c sub $0xc,%esp 116cbd: 8b 7d 0c mov 0xc(%ebp),%edi Heap_Block *the_block; Heap_Block *next_block; uint32_t the_size; if ( !_Addresses_Is_in_range( 116cc0: 8b 45 08 mov 0x8(%ebp),%eax 116cc3: 8b 70 24 mov 0x24(%eax),%esi 116cc6: 8b 48 20 mov 0x20(%eax),%ecx /* end of include file */ 116cc9: 39 f9 cmp %edi,%ecx 116ccb: 77 04 ja 116cd1 <_Heap_Size_of_user_area+0x1d> 116ccd: 39 fe cmp %edi,%esi 116ccf: 73 0b jae 116cdc <_Heap_Size_of_user_area+0x28><== ALWAYS TAKEN area of 'the_block'. */ *size = _Addresses_Subtract ( next_block, starting_address ) + HEAP_BLOCK_HEADER_OFFSET; return( TRUE ); 116cd1: 31 c0 xor %eax,%eax } 116cd3: 83 c4 0c add $0xc,%esp 116cd6: 5b pop %ebx 116cd7: 5e pop %esi 116cd8: 5f pop %edi 116cd9: c9 leave 116cda: c3 ret 116cdb: 90 nop 116cdc: 8d 57 f8 lea -0x8(%edi),%edx 116cdf: 89 55 e8 mov %edx,-0x18(%ebp) 116ce2: 89 f8 mov %edi,%eax 116ce4: 8b 5d 08 mov 0x8(%ebp),%ebx 116ce7: 31 d2 xor %edx,%edx 116ce9: f7 73 10 divl 0x10(%ebx) 116cec: 29 55 e8 sub %edx,-0x18(%ebp) /* end of include file */ 116cef: 3b 4d e8 cmp -0x18(%ebp),%ecx 116cf2: 77 dd ja 116cd1 <_Heap_Size_of_user_area+0x1d><== NEVER TAKEN 116cf4: 3b 75 e8 cmp -0x18(%ebp),%esi 116cf7: 72 d8 jb 116cd1 <_Heap_Size_of_user_area+0x1d><== NEVER TAKEN 116cf9: 8b 55 e8 mov -0x18(%ebp),%edx 116cfc: 8b 42 04 mov 0x4(%edx),%eax 116cff: 83 e0 fe and $0xfffffffe,%eax 116d02: 01 d0 add %edx,%eax /* end of include file */ 116d04: 39 c1 cmp %eax,%ecx 116d06: 77 c9 ja 116cd1 <_Heap_Size_of_user_area+0x1d><== NEVER TAKEN 116d08: 39 c6 cmp %eax,%esi 116d0a: 72 c5 jb 116cd1 <_Heap_Size_of_user_area+0x1d><== NEVER TAKEN 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 ( 116d0c: f6 40 04 01 testb $0x1,0x4(%eax) 116d10: 74 bf je 116cd1 <_Heap_Size_of_user_area+0x1d><== NEVER TAKEN 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 ) 116d12: 29 f8 sub %edi,%eax 116d14: 83 c0 04 add $0x4,%eax 116d17: 8b 5d 10 mov 0x10(%ebp),%ebx 116d1a: 89 03 mov %eax,(%ebx) 116d1c: b0 01 mov $0x1,%al 116d1e: eb b3 jmp 116cd3 <_Heap_Size_of_user_area+0x1f> =============================================================================== 00111644 <_Heap_Walk>: bool _Heap_Walk( Heap_Control *the_heap, int source, bool do_dump ) { 111644: 55 push %ebp 111645: 89 e5 mov %esp,%ebp 111647: 57 push %edi 111648: 56 push %esi 111649: 53 push %ebx 11164a: 83 ec 1c sub $0x1c,%esp 11164d: 8b 75 08 mov 0x8(%ebp),%esi Heap_Block *the_block = the_heap->start; 111650: 8b 7e 20 mov 0x20(%esi),%edi Heap_Block *const end = the_heap->final; 111653: 8b 46 24 mov 0x24(%esi),%eax 111656: 89 45 e4 mov %eax,-0x1c(%ebp) /* if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) 111659: 8b 45 0c mov 0xc(%ebp),%eax 11165c: 85 c0 test %eax,%eax 11165e: 0f 88 67 02 00 00 js 1118cb <_Heap_Walk+0x287> <== NEVER TAKEN /* * Handle the 1st block */ if (!_Heap_Is_prev_used(the_block)) { 111664: f6 47 04 01 testb $0x1,0x4(%edi) 111668: 0f 84 3e 02 00 00 je 1118ac <_Heap_Walk+0x268> <== NEVER TAKEN 11166e: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp) 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) { 111675: 8b 07 mov (%edi),%eax 111677: 3b 46 10 cmp 0x10(%esi),%eax 11167a: 74 1a je 111696 <_Heap_Walk+0x52> <== ALWAYS TAKEN printk("PASS: %d !prev_size of 1st block isn't page_size\n", source); 11167c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11167f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111682: 68 e8 cb 11 00 push $0x11cbe8 <== NOT EXECUTED 111687: e8 38 7d ff ff call 1093c4 <== NOT EXECUTED 11168c: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111693: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } while ( the_block != end ) { 111696: 3b 7d e4 cmp -0x1c(%ebp),%edi 111699: 0f 84 37 02 00 00 je 1118d6 <_Heap_Walk+0x292> <== NEVER TAKEN 11169f: 8b 57 04 mov 0x4(%edi),%edx 1116a2: 89 d3 mov %edx,%ebx 1116a4: 83 e3 fe and $0xfffffffe,%ebx /** @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 1116a7: 8d 04 1f lea (%edi,%ebx,1),%eax 1116aa: 89 45 ec mov %eax,-0x14(%ebp) 1116ad: 8b 46 24 mov 0x24(%esi),%eax #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 ); 1116b0: 8b 4d ec mov -0x14(%ebp),%ecx 1116b3: 39 4e 20 cmp %ecx,0x20(%esi) 1116b6: 0f 87 14 01 00 00 ja 1117d0 <_Heap_Walk+0x18c> <== NEVER TAKEN 1116bc: 39 c1 cmp %eax,%ecx 1116be: 0f 87 0c 01 00 00 ja 1117d0 <_Heap_Walk+0x18c> <== NEVER TAKEN 1116c4: 83 e2 01 and $0x1,%edx 1116c7: 88 55 f3 mov %dl,-0xd(%ebp) 1116ca: 66 90 xchg %ax,%ax printk("PASS: %d !block %p is out of heap\n", source, next_block); error = 1; break; } if (!_Heap_Is_prev_used(next_block)) { 1116cc: 8b 4d ec mov -0x14(%ebp),%ecx 1116cf: f6 41 04 01 testb $0x1,0x4(%ecx) 1116d3: 0f 85 53 01 00 00 jne 11182c <_Heap_Walk+0x1e8> if (do_dump) printk( " prev %p next %p", the_block->prev, the_block->next); if (_Heap_Block_size(the_block) != next_block->prev_size) { 1116d9: 8b 45 ec mov -0x14(%ebp),%eax 1116dc: 39 18 cmp %ebx,(%eax) 1116de: 74 1a je 1116fa <_Heap_Walk+0xb6> <== ALWAYS TAKEN if (do_dump) printk("\n"); printk("PASS: %d !front and back sizes don't match", source); 1116e0: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1116e3: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1116e6: 68 40 cc 11 00 push $0x11cc40 <== NOT EXECUTED 1116eb: e8 d4 7c ff ff call 1093c4 <== NOT EXECUTED 1116f0: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 1116f7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } if (!prev_used) { 1116fa: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) 1116fe: 75 25 jne 111725 <_Heap_Walk+0xe1> <== ALWAYS TAKEN if (do_dump || error) printk("\n"); 111700: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 111703: 85 c0 test %eax,%eax <== NOT EXECUTED 111705: 0f 85 81 01 00 00 jne 11188c <_Heap_Walk+0x248> <== NOT EXECUTED printk("PASS: %d !two consecutive blocks are free", source); 11170b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11170e: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111711: 68 6c cc 11 00 push $0x11cc6c <== NOT EXECUTED 111716: e8 a9 7c ff ff call 1093c4 <== NOT EXECUTED 11171b: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111722: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { return ( the_thread == _Thread_Heir ); } /** 111725: 8b 46 08 mov 0x8(%esi),%eax 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) 111728: 39 c7 cmp %eax,%edi 11172a: 75 13 jne 11173f <_Heap_Walk+0xfb> 11172c: e9 fb 00 00 00 jmp 11182c <_Heap_Walk+0x1e8> 111731: 8d 76 00 lea 0x0(%esi),%esi block = block->next; 111734: 8b 40 08 mov 0x8(%eax),%eax 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) 111737: 39 f8 cmp %edi,%eax 111739: 0f 84 ed 00 00 00 je 11182c <_Heap_Walk+0x1e8> 11173f: 39 c6 cmp %eax,%esi 111741: 75 f1 jne 111734 <_Heap_Walk+0xf0> <== ALWAYS TAKEN block = block->next; if(block != the_block) { if (do_dump || error) printk("\n"); 111743: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 111746: 85 c9 test %ecx,%ecx <== NOT EXECUTED 111748: 74 10 je 11175a <_Heap_Walk+0x116> <== NOT EXECUTED 11174a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11174d: 68 4b a7 11 00 push $0x11a74b <== NOT EXECUTED 111752: e8 6d 7c ff ff call 1093c4 <== NOT EXECUTED 111757: 83 c4 10 add $0x10,%esp <== NOT EXECUTED printk("PASS: %d !the_block not in the free list", source); 11175a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11175d: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111760: 68 98 cc 11 00 push $0x11cc98 <== NOT EXECUTED 111765: e8 5a 7c ff ff call 1093c4 <== NOT EXECUTED 11176a: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 111771: 83 c4 10 add $0x10,%esp <== NOT EXECUTED error = 1; } } } if (do_dump || error) printk("\n"); 111774: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 111777: 68 4b a7 11 00 push $0x11a74b <== NOT EXECUTED 11177c: e8 43 7c ff ff call 1093c4 <== NOT EXECUTED 111781: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if (the_size < the_heap->min_block_size) { 111784: 3b 5e 14 cmp 0x14(%esi),%ebx <== NOT EXECUTED 111787: 0f 82 b3 00 00 00 jb 111840 <_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)) { 11178d: 89 d8 mov %ebx,%eax 11178f: 31 d2 xor %edx,%edx 111791: f7 76 10 divl 0x10(%esi) 111794: 85 d2 test %edx,%edx 111796: 0f 85 d8 00 00 00 jne 111874 <_Heap_Walk+0x230> <== NEVER TAKEN printk("PASS: %d !block size is misaligned\n", source); error = 1; } if (++passes > (do_dump ? 10 : 0) && error) 11179c: 8b 45 e8 mov -0x18(%ebp),%eax 11179f: 85 c0 test %eax,%eax 1117a1: 75 41 jne 1117e4 <_Heap_Walk+0x1a0> <== NEVER TAKEN 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 ) { 1117a3: 8b 4d ec mov -0x14(%ebp),%ecx 1117a6: 39 4d e4 cmp %ecx,-0x1c(%ebp) 1117a9: 0f 84 27 01 00 00 je 1118d6 <_Heap_Walk+0x292> 1117af: 8b 45 ec mov -0x14(%ebp),%eax 1117b2: 8b 48 04 mov 0x4(%eax),%ecx 1117b5: 89 cb mov %ecx,%ebx 1117b7: 83 e3 fe and $0xfffffffe,%ebx 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 ); 1117ba: 01 d8 add %ebx,%eax 1117bc: 8b 56 24 mov 0x24(%esi),%edx #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 ); 1117bf: 3b 46 20 cmp 0x20(%esi),%eax 1117c2: 0f 83 90 00 00 00 jae 111858 <_Heap_Walk+0x214> <== ALWAYS TAKEN printk("PASS: %d !block %p is out of heap\n", source, next_block); error = 1; break; } if (!_Heap_Is_prev_used(next_block)) { 1117c8: 8b 7d ec mov -0x14(%ebp),%edi <== NOT EXECUTED 1117cb: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 1117ce: 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); 1117d0: 50 push %eax <== NOT EXECUTED 1117d1: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 1117d4: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1117d7: 68 1c cc 11 00 push $0x11cc1c <== NOT EXECUTED 1117dc: e8 e3 7b ff ff call 1093c4 <== NOT EXECUTED 1117e1: 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", 1117e4: ff 75 e4 pushl -0x1c(%ebp) <== NOT EXECUTED 1117e7: 57 push %edi <== NOT EXECUTED 1117e8: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1117eb: 68 0c cd 11 00 push $0x11cd0c <== NOT EXECUTED 1117f0: e8 cf 7b ff ff call 1093c4 <== NOT EXECUTED 1117f5: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 1117fc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1117ff: 8b 47 04 mov 0x4(%edi),%eax 111802: 83 e0 fe and $0xfffffffe,%eax source, the_block, end); error = 1; } if (_Heap_Block_size(the_block) != the_heap->page_size) { 111805: 8b 56 10 mov 0x10(%esi),%edx 111808: 39 c2 cmp %eax,%edx 11180a: 0f 84 91 00 00 00 je 1118a1 <_Heap_Walk+0x25d> <== ALWAYS TAKEN printk("PASS: %d !last block's size isn't page_size (%d != %d)\n", source, 111810: 52 push %edx <== NOT EXECUTED 111811: 50 push %eax <== NOT EXECUTED 111812: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111815: 68 48 cd 11 00 push $0x11cd48 <== NOT EXECUTED 11181a: e8 a5 7b ff ff call 1093c4 <== NOT EXECUTED 11181f: b0 01 mov $0x1,%al <== NOT EXECUTED 111821: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if(do_dump && error) _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 ); return error; } 111824: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 111827: 5b pop %ebx <== NOT EXECUTED 111828: 5e pop %esi <== NOT EXECUTED 111829: 5f pop %edi <== NOT EXECUTED 11182a: c9 leave <== NOT EXECUTED 11182b: c3 ret <== NOT EXECUTED error = 1; } } } if (do_dump || error) printk("\n"); 11182c: 8b 55 e8 mov -0x18(%ebp),%edx 11182f: 85 d2 test %edx,%edx 111831: 0f 85 3d ff ff ff jne 111774 <_Heap_Walk+0x130> <== NEVER TAKEN if (the_size < the_heap->min_block_size) { 111837: 3b 5e 14 cmp 0x14(%esi),%ebx 11183a: 0f 83 4d ff ff ff jae 11178d <_Heap_Walk+0x149> <== ALWAYS TAKEN printk("PASS: %d !block size is too small\n", source); 111840: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111843: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 111846: 68 c4 cc 11 00 push $0x11ccc4 <== NOT EXECUTED 11184b: e8 74 7b ff ff call 1093c4 <== NOT EXECUTED 111850: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111853: eb 8f jmp 1117e4 <_Heap_Walk+0x1a0> <== NOT EXECUTED 111855: 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 ); 111858: 39 d0 cmp %edx,%eax 11185a: 0f 87 68 ff ff ff ja 1117c8 <_Heap_Walk+0x184> <== NEVER TAKEN 111860: 83 e1 01 and $0x1,%ecx 111863: 88 4d f3 mov %cl,-0xd(%ebp) 111866: 8b 7d ec mov -0x14(%ebp),%edi 111869: 89 45 ec mov %eax,-0x14(%ebp) 11186c: e9 5b fe ff ff jmp 1116cc <_Heap_Walk+0x88> 111871: 8d 76 00 lea 0x0(%esi),%esi error = 1; break; } if (!_Heap_Is_aligned( the_size, the_heap->page_size)) { printk("PASS: %d !block size is misaligned\n", source); 111874: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 111877: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 11187a: 68 e8 cc 11 00 push $0x11cce8 <== NOT EXECUTED 11187f: e8 40 7b ff ff call 1093c4 <== NOT EXECUTED 111884: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 111887: e9 58 ff ff ff jmp 1117e4 <_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"); 11188c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 11188f: 68 4b a7 11 00 push $0x11a74b <== NOT EXECUTED 111894: e8 2b 7b ff ff call 1093c4 <== NOT EXECUTED 111899: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11189c: e9 6a fe ff ff jmp 11170b <_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) { 1118a1: 8a 45 e8 mov -0x18(%ebp),%al if(do_dump && error) _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, 0xffff0000 ); return error; } 1118a4: 8d 65 f4 lea -0xc(%ebp),%esp 1118a7: 5b pop %ebx 1118a8: 5e pop %esi 1118a9: 5f pop %edi 1118aa: c9 leave 1118ab: c3 ret /* * 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); 1118ac: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1118af: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 1118b2: 68 b0 cb 11 00 push $0x11cbb0 <== NOT EXECUTED 1118b7: e8 08 7b ff ff call 1093c4 <== NOT EXECUTED 1118bc: c7 45 e8 01 00 00 00 movl $0x1,-0x18(%ebp) <== NOT EXECUTED 1118c3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1118c6: e9 aa fd ff ff jmp 111675 <_Heap_Walk+0x31> <== NOT EXECUTED if ( !_System_state_Is_up( _System_state_Get() ) ) return TRUE; */ if (source < 0) source = the_heap->stats.instance; 1118cb: 8b 4e 28 mov 0x28(%esi),%ecx <== NOT EXECUTED 1118ce: 89 4d 0c mov %ecx,0xc(%ebp) <== NOT EXECUTED 1118d1: e9 8e fd ff ff jmp 111664 <_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, 1118d6: 8b 7d e4 mov -0x1c(%ebp),%edi 1118d9: e9 21 ff ff ff jmp 1117ff <_Heap_Walk+0x1bb> =============================================================================== 0010aa98 <_IO_Initialize_all_drivers>: * * Output Parameters: NONE */ void _IO_Initialize_all_drivers( void ) { 10aa98: 55 push %ebp 10aa99: 89 e5 mov %esp,%ebp 10aa9b: 53 push %ebx 10aa9c: 83 ec 04 sub $0x4,%esp rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10aa9f: 8b 15 00 ea 11 00 mov 0x11ea00,%edx 10aaa5: 85 d2 test %edx,%edx 10aaa7: 74 1a je 10aac3 <_IO_Initialize_all_drivers+0x2b><== NEVER TAKEN 10aaa9: 31 db xor %ebx,%ebx 10aaab: 90 nop (void) rtems_io_initialize( major, 0, NULL ); 10aaac: 50 push %eax 10aaad: 6a 00 push $0x0 10aaaf: 6a 00 push $0x0 10aab1: 53 push %ebx 10aab2: e8 4d 45 00 00 call 10f004 void _IO_Initialize_all_drivers( void ) { rtems_device_major_number major; for ( major=0 ; major < _IO_Number_of_drivers ; major ++ ) 10aab7: 43 inc %ebx 10aab8: 83 c4 10 add $0x10,%esp 10aabb: 39 1d 00 ea 11 00 cmp %ebx,0x11ea00 10aac1: 77 e9 ja 10aaac <_IO_Initialize_all_drivers+0x14> (void) rtems_io_initialize( major, 0, NULL ); } 10aac3: 8b 5d fc mov -0x4(%ebp),%ebx 10aac6: c9 leave 10aac7: c3 ret =============================================================================== 0010aac8 <_IO_Manager_initialization>: void _IO_Manager_initialization( rtems_driver_address_table *driver_table, uint32_t drivers_in_table, uint32_t number_of_drivers ) { 10aac8: 55 push %ebp 10aac9: 89 e5 mov %esp,%ebp 10aacb: 57 push %edi 10aacc: 56 push %esi 10aacd: 53 push %ebx 10aace: 83 ec 0c sub $0xc,%esp 10aad1: 8b 75 10 mov 0x10(%ebp),%esi /* * 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 ) 10aad4: 3b 75 0c cmp 0xc(%ebp),%esi 10aad7: 76 5b jbe 10ab34 <_IO_Manager_initialization+0x6c> /* * 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 *) 10aad9: 8d 04 76 lea (%esi,%esi,2),%eax 10aadc: 8d 1c c5 00 00 00 00 lea 0x0(,%eax,8),%ebx 10aae3: 83 ec 0c sub $0xc,%esp 10aae6: 53 push %ebx 10aae7: e8 4c 29 00 00 call 10d438 <_Workspace_Allocate_or_fatal_error> 10aaec: 89 c7 mov %eax,%edi 10aaee: a3 04 ea 11 00 mov %eax,0x11ea04 _Workspace_Allocate_or_fatal_error( sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); _IO_Number_of_drivers = number_of_drivers; 10aaf3: 89 35 00 ea 11 00 mov %esi,0x11ea00 memset( 10aaf9: 31 c0 xor %eax,%eax 10aafb: 89 d9 mov %ebx,%ecx 10aafd: f3 aa rep stos %al,%es:(%edi) _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 10aaff: 83 c4 10 add $0x10,%esp 10ab02: 8b 4d 0c mov 0xc(%ebp),%ecx 10ab05: 85 c9 test %ecx,%ecx 10ab07: 74 23 je 10ab2c <_IO_Manager_initialization+0x64><== NEVER TAKEN _IO_Driver_address_table[index] = driver_table[index]; 10ab09: 8b 1d 04 ea 11 00 mov 0x11ea04,%ebx 10ab0f: 31 d2 xor %edx,%edx 10ab11: 31 c0 xor %eax,%eax 10ab13: 90 nop 10ab14: 8d 3c 03 lea (%ebx,%eax,1),%edi 10ab17: 8b 75 08 mov 0x8(%ebp),%esi 10ab1a: 01 c6 add %eax,%esi 10ab1c: b9 06 00 00 00 mov $0x6,%ecx 10ab21: f3 a5 rep movsl %ds:(%esi),%es:(%edi) memset( _IO_Driver_address_table, 0, sizeof( rtems_driver_address_table ) * ( number_of_drivers ) ); for ( index = 0 ; index < drivers_in_table ; index++ ) 10ab23: 42 inc %edx 10ab24: 83 c0 18 add $0x18,%eax 10ab27: 39 55 0c cmp %edx,0xc(%ebp) 10ab2a: 77 e8 ja 10ab14 <_IO_Manager_initialization+0x4c> _IO_Driver_address_table[index] = driver_table[index]; number_of_drivers = drivers_in_table; } 10ab2c: 8d 65 f4 lea -0xc(%ebp),%esp 10ab2f: 5b pop %ebx 10ab30: 5e pop %esi 10ab31: 5f pop %edi 10ab32: c9 leave 10ab33: c3 ret * 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; 10ab34: 8b 45 08 mov 0x8(%ebp),%eax 10ab37: a3 04 ea 11 00 mov %eax,0x11ea04 _IO_Number_of_drivers = number_of_drivers; 10ab3c: 8b 4d 0c mov 0xc(%ebp),%ecx 10ab3f: 89 0d 00 ea 11 00 mov %ecx,0x11ea00 ); for ( index = 0 ; index < drivers_in_table ; index++ ) _IO_Driver_address_table[index] = driver_table[index]; number_of_drivers = drivers_in_table; } 10ab45: 8d 65 f4 lea -0xc(%ebp),%esp 10ab48: 5b pop %ebx 10ab49: 5e pop %esi 10ab4a: 5f pop %edi 10ab4b: c9 leave 10ab4c: c3 ret =============================================================================== 0010b520 <_Internal_error_Occurred>: void _Internal_error_Occurred( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10b520: 55 push %ebp 10b521: 89 e5 mov %esp,%ebp 10b523: 53 push %ebx 10b524: 83 ec 08 sub $0x8,%esp 10b527: 8b 55 08 mov 0x8(%ebp),%edx 10b52a: 8b 45 0c mov 0xc(%ebp),%eax 10b52d: 8b 5d 10 mov 0x10(%ebp),%ebx _Internal_errors_What_happened.the_source = the_source; 10b530: 89 15 04 e7 11 00 mov %edx,0x11e704 _Internal_errors_What_happened.is_internal = is_internal; 10b536: a2 08 e7 11 00 mov %al,0x11e708 _Internal_errors_What_happened.the_error = the_error; 10b53b: 89 1d 0c e7 11 00 mov %ebx,0x11e70c _User_extensions_Fatal( the_source, is_internal, the_error ); 10b541: 53 push %ebx 10b542: 0f b6 c0 movzbl %al,%eax 10b545: 50 push %eax 10b546: 52 push %edx 10b547: e8 60 1b 00 00 call 10d0ac <_User_extensions_Fatal> * @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( 10b54c: c7 05 24 e8 11 00 05 movl $0x5,0x11e824 <== NOT EXECUTED 10b553: 00 00 00 _System_state_Set( SYSTEM_STATE_FAILED ); _CPU_Fatal_halt( the_error ); 10b556: fa cli <== NOT EXECUTED 10b557: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10b559: f4 hlt <== NOT EXECUTED 10b55a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b55d: eb fe jmp 10b55d <_Internal_error_Occurred+0x3d><== NOT EXECUTED =============================================================================== 0010f4bc <_Objects_API_maximum_class>: #include int _Objects_API_maximum_class( uint32_t api ) { 10f4bc: 55 push %ebp 10f4bd: 89 e5 mov %esp,%ebp switch (api) { 10f4bf: 83 7d 08 02 cmpl $0x2,0x8(%ebp) 10f4c3: 74 2f je 10f4f4 <_Objects_API_maximum_class+0x38> 10f4c5: 76 15 jbe 10f4dc <_Objects_API_maximum_class+0x20> 10f4c7: 83 7d 08 03 cmpl $0x3,0x8(%ebp) 10f4cb: 74 1f je 10f4ec <_Objects_API_maximum_class+0x30><== NEVER TAKEN 10f4cd: 83 7d 08 04 cmpl $0x4,0x8(%ebp) 10f4d1: 75 0f jne 10f4e2 <_Objects_API_maximum_class+0x26> 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; 10f4d3: b8 08 00 00 00 mov $0x8,%eax case OBJECTS_NO_API: default: break; } return -1; } 10f4d8: c9 leave 10f4d9: c3 ret 10f4da: 66 90 xchg %ax,%ax int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10f4dc: 83 7d 08 01 cmpl $0x1,0x8(%ebp) 10f4e0: 74 1a je 10f4fc <_Objects_API_maximum_class+0x40> 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; 10f4e2: b8 ff ff ff ff mov $0xffffffff,%eax case OBJECTS_NO_API: default: break; } return -1; } 10f4e7: c9 leave 10f4e8: c3 ret 10f4e9: 8d 76 00 lea 0x0(%esi),%esi int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10f4ec: b8 0c 00 00 00 mov $0xc,%eax <== NOT EXECUTED case OBJECTS_NO_API: default: break; } return -1; } 10f4f1: c9 leave <== NOT EXECUTED 10f4f2: c3 ret <== NOT EXECUTED 10f4f3: 90 nop <== NOT EXECUTED int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10f4f4: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_NO_API: default: break; } return -1; } 10f4f9: c9 leave 10f4fa: c3 ret 10f4fb: 90 nop int _Objects_API_maximum_class( uint32_t api ) { switch (api) { 10f4fc: b8 02 00 00 00 mov $0x2,%eax case OBJECTS_NO_API: default: break; } return -1; } 10f501: c9 leave 10f502: c3 ret =============================================================================== 0010b5b4 <_Objects_Allocate>: */ Objects_Control *_Objects_Allocate( Objects_Information *information ) { 10b5b4: 55 push %ebp 10b5b5: 89 e5 mov %esp,%ebp 10b5b7: 56 push %esi 10b5b8: 53 push %ebx 10b5b9: 8b 5d 08 mov 0x8(%ebp),%ebx * 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 ) 10b5bc: 8b 43 18 mov 0x18(%ebx),%eax 10b5bf: 85 c0 test %eax,%eax 10b5c1: 75 0d jne 10b5d0 <_Objects_Allocate+0x1c><== ALWAYS TAKEN 10b5c3: 31 c9 xor %ecx,%ecx <== NOT EXECUTED information->inactive--; } } return the_object; } 10b5c5: 89 c8 mov %ecx,%eax 10b5c7: 8d 65 f8 lea -0x8(%ebp),%esp 10b5ca: 5b pop %ebx 10b5cb: 5e pop %esi 10b5cc: c9 leave 10b5cd: c3 ret 10b5ce: 66 90 xchg %ax,%ax /* * 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 ); 10b5d0: 8d 73 20 lea 0x20(%ebx),%esi 10b5d3: 83 ec 0c sub $0xc,%esp 10b5d6: 56 push %esi 10b5d7: e8 c4 f7 ff ff call 10ada0 <_Chain_Get> 10b5dc: 89 c1 mov %eax,%ecx if ( information->auto_extend ) { 10b5de: 83 c4 10 add $0x10,%esp 10b5e1: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10b5e5: 74 de je 10b5c5 <_Objects_Allocate+0x11> /* * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { 10b5e7: 85 c0 test %eax,%eax 10b5e9: 74 2d je 10b618 <_Objects_Allocate+0x64> } if ( the_object ) { uint32_t block; block = _Objects_Get_index( the_object->id ) - 10b5eb: 8b 41 08 mov 0x8(%ecx),%eax 10b5ee: 25 ff ff 00 00 and $0xffff,%eax 10b5f3: 8b 53 08 mov 0x8(%ebx),%edx 10b5f6: 81 e2 ff ff 00 00 and $0xffff,%edx 10b5fc: 29 d0 sub %edx,%eax _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]--; 10b5fe: 31 d2 xor %edx,%edx 10b600: f7 73 14 divl 0x14(%ebx) 10b603: c1 e0 02 shl $0x2,%eax 10b606: 03 43 30 add 0x30(%ebx),%eax 10b609: ff 08 decl (%eax) information->inactive--; 10b60b: 66 ff 4b 2c decw 0x2c(%ebx) } } return the_object; } 10b60f: 89 c8 mov %ecx,%eax 10b611: 8d 65 f8 lea -0x8(%ebp),%esp 10b614: 5b pop %ebx 10b615: 5e pop %esi 10b616: c9 leave 10b617: c3 ret * If the list is empty then we are out of objects and need to * extend information base. */ if ( !the_object ) { _Objects_Extend_information( information ); 10b618: 83 ec 0c sub $0xc,%esp 10b61b: 53 push %ebx 10b61c: e8 37 00 00 00 call 10b658 <_Objects_Extend_information> the_object = (Objects_Control *) _Chain_Get( &information->Inactive ); 10b621: 89 34 24 mov %esi,(%esp) 10b624: e8 77 f7 ff ff call 10ada0 <_Chain_Get> 10b629: 89 c1 mov %eax,%ecx } if ( the_object ) { 10b62b: 83 c4 10 add $0x10,%esp 10b62e: 85 c0 test %eax,%eax 10b630: 74 93 je 10b5c5 <_Objects_Allocate+0x11><== NEVER TAKEN 10b632: eb b7 jmp 10b5eb <_Objects_Allocate+0x37> =============================================================================== 0010b658 <_Objects_Extend_information>: */ void _Objects_Extend_information( Objects_Information *information ) { 10b658: 55 push %ebp 10b659: 89 e5 mov %esp,%ebp 10b65b: 57 push %edi 10b65c: 56 push %esi 10b65d: 53 push %ebx 10b65e: 83 ec 5c sub $0x5c,%esp * 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 10b661: 8b 55 08 mov 0x8(%ebp),%edx 10b664: 8b 42 08 mov 0x8(%edx),%eax 10b667: 25 ff ff 00 00 and $0xffff,%eax 10b66c: 89 45 c8 mov %eax,-0x38(%ebp) minimum_index = _Objects_Get_index( information->minimum_id ); index_base = minimum_index; block = 0; if ( information->maximum < minimum_index ) 10b66f: 0f b7 72 10 movzwl 0x10(%edx),%esi 10b673: 39 c6 cmp %eax,%esi 10b675: 0f 83 e9 01 00 00 jae 10b864 <_Objects_Extend_information+0x20c> 10b67b: 8b 4a 14 mov 0x14(%edx),%ecx 10b67e: 89 4d a8 mov %ecx,-0x58(%ebp) 10b681: 89 45 c4 mov %eax,-0x3c(%ebp) 10b684: c7 45 c0 00 00 00 00 movl $0x0,-0x40(%ebp) 10b68b: 31 db xor %ebx,%ebx 10b68d: c7 45 e0 01 00 00 00 movl $0x1,-0x20(%ebp) 10b694: ba 03 00 00 00 mov $0x3,%edx * Up the block count and maximum */ block_count++; maximum = information->maximum + information->allocation_size; 10b699: 03 75 a8 add -0x58(%ebp),%esi 10b69c: 89 75 d4 mov %esi,-0x2c(%ebp) /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { 10b69f: 8b 45 08 mov 0x8(%ebp),%eax 10b6a2: 80 78 12 00 cmpb $0x0,0x12(%eax) 10b6a6: 0f 85 1c 02 00 00 jne 10b8c8 <_Objects_Extend_information+0x270> if ( !object_blocks ) return; } else { object_blocks = (void**) 10b6ac: 83 ec 0c sub $0xc,%esp 10b6af: 8b 75 c8 mov -0x38(%ebp),%esi 10b6b2: 8d 04 32 lea (%edx,%esi,1),%eax 10b6b5: 03 45 d4 add -0x2c(%ebp),%eax 10b6b8: c1 e0 02 shl $0x2,%eax 10b6bb: 50 push %eax 10b6bc: e8 77 1d 00 00 call 10d438 <_Workspace_Allocate_or_fatal_error> 10b6c1: 89 45 cc mov %eax,-0x34(%ebp) 10b6c4: 83 c4 10 add $0x10,%esp /* * Break the block into the various sections. * */ inactive_per_block = (uint32_t *) _Addresses_Add_offset( 10b6c7: 8b 7d e0 mov -0x20(%ebp),%edi 10b6ca: 8b 45 cc mov -0x34(%ebp),%eax 10b6cd: 8d 3c b8 lea (%eax,%edi,4),%edi 10b6d0: 89 7d d0 mov %edi,-0x30(%ebp) * @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 10b6d3: 8b 55 e0 mov -0x20(%ebp),%edx 10b6d6: 8d 14 d0 lea (%eax,%edx,8),%edx 10b6d9: 89 55 d8 mov %edx,-0x28(%ebp) * in the copies. */ block_count--; if ( information->maximum > minimum_index ) { 10b6dc: 8b 4d 08 mov 0x8(%ebp),%ecx 10b6df: 0f b7 41 10 movzwl 0x10(%ecx),%eax 10b6e3: 3b 45 c8 cmp -0x38(%ebp),%eax 10b6e6: 0f 87 38 02 00 00 ja 10b924 <_Objects_Extend_information+0x2cc> else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10b6ec: 8b 45 c8 mov -0x38(%ebp),%eax 10b6ef: 85 c0 test %eax,%eax 10b6f1: 74 15 je 10b708 <_Objects_Extend_information+0xb0><== NEVER TAKEN information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10b6f3: 31 c0 xor %eax,%eax 10b6f5: 8d 76 00 lea 0x0(%esi),%esi /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { local_table[ index ] = NULL; 10b6f8: 8b 55 d8 mov -0x28(%ebp),%edx 10b6fb: c7 04 82 00 00 00 00 movl $0x0,(%edx,%eax,4) else { /* * Deal with the special case of the 0 to minimum_index */ for ( index = 0; index < minimum_index; index++ ) { 10b702: 40 inc %eax 10b703: 3b 45 c8 cmp -0x38(%ebp),%eax 10b706: 72 f0 jb 10b6f8 <_Objects_Extend_information+0xa0><== NEVER TAKEN /* * Initialise the new entries in the table. */ object_blocks[block_count] = NULL; 10b708: 8b 45 c0 mov -0x40(%ebp),%eax 10b70b: c1 e0 02 shl $0x2,%eax 10b70e: 8b 4d cc mov -0x34(%ebp),%ecx 10b711: c7 04 01 00 00 00 00 movl $0x0,(%ecx,%eax,1) inactive_per_block[block_count] = 0; 10b718: 8b 75 d0 mov -0x30(%ebp),%esi 10b71b: c7 04 06 00 00 00 00 movl $0x0,(%esi,%eax,1) for ( index=index_base ; index < ( information->allocation_size + index_base ); 10b722: 8b 4d c4 mov -0x3c(%ebp),%ecx 10b725: 8b 7d 08 mov 0x8(%ebp),%edi 10b728: 03 4f 14 add 0x14(%edi),%ecx 10b72b: 3b 4d c4 cmp -0x3c(%ebp),%ecx 10b72e: 76 1a jbe 10b74a <_Objects_Extend_information+0xf2><== NEVER TAKEN 10b730: 8b 45 c4 mov -0x3c(%ebp),%eax 10b733: 8b 75 d8 mov -0x28(%ebp),%esi 10b736: 8d 14 86 lea (%esi,%eax,4),%edx 10b739: 8d 76 00 lea 0x0(%esi),%esi index++ ) { local_table[ index ] = NULL; 10b73c: c7 02 00 00 00 00 movl $0x0,(%edx) object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); index++ ) { 10b742: 40 inc %eax 10b743: 83 c2 04 add $0x4,%edx object_blocks[block_count] = NULL; inactive_per_block[block_count] = 0; for ( index=index_base ; index < ( information->allocation_size + index_base ); 10b746: 39 c1 cmp %eax,%ecx 10b748: 77 f2 ja 10b73c <_Objects_Extend_information+0xe4> index++ ) { local_table[ index ] = NULL; } _ISR_Disable( level ); 10b74a: 9c pushf 10b74b: fa cli 10b74c: 59 pop %ecx old_tables = information->object_blocks; 10b74d: 8b 7d 08 mov 0x8(%ebp),%edi 10b750: 8b 77 34 mov 0x34(%edi),%esi information->object_blocks = object_blocks; 10b753: 8b 45 cc mov -0x34(%ebp),%eax 10b756: 89 47 34 mov %eax,0x34(%edi) information->inactive_per_block = inactive_per_block; 10b759: 8b 55 d0 mov -0x30(%ebp),%edx 10b75c: 89 57 30 mov %edx,0x30(%edi) information->local_table = local_table; 10b75f: 8b 45 d8 mov -0x28(%ebp),%eax 10b762: 89 47 1c mov %eax,0x1c(%edi) information->maximum = maximum; 10b765: 8b 55 d4 mov -0x2c(%ebp),%edx 10b768: 66 89 57 10 mov %dx,0x10(%edi) information->maximum_id = _Objects_Build_id( 10b76c: 8b 17 mov (%edi),%edx 10b76e: c1 e2 18 shl $0x18,%edx 10b771: 81 ca 00 00 01 00 or $0x10000,%edx 10b777: 0f b7 47 04 movzwl 0x4(%edi),%eax 10b77b: c1 e0 1b shl $0x1b,%eax 10b77e: 09 c2 or %eax,%edx 10b780: 0f b7 45 d4 movzwl -0x2c(%ebp),%eax 10b784: 09 c2 or %eax,%edx 10b786: 89 57 0c mov %edx,0xc(%edi) information->the_class, _Objects_Local_node, information->maximum ); _ISR_Enable( level ); 10b789: 51 push %ecx 10b78a: 9d popf if ( old_tables ) 10b78b: 85 f6 test %esi,%esi 10b78d: 0f 84 c9 01 00 00 je 10b95c <_Objects_Extend_information+0x304> _Workspace_Free( old_tables ); 10b793: 83 ec 0c sub $0xc,%esp 10b796: 56 push %esi 10b797: e8 6c 1c 00 00 call 10d408 <_Workspace_Free> 10b79c: 8b 75 08 mov 0x8(%ebp),%esi 10b79f: 8b 76 14 mov 0x14(%esi),%esi 10b7a2: 89 75 a8 mov %esi,-0x58(%ebp) 10b7a5: 83 c4 10 add $0x10,%esp /* * Allocate the name table, and the objects */ if ( information->auto_extend ) { 10b7a8: 8b 7d 08 mov 0x8(%ebp),%edi 10b7ab: 80 7f 12 00 cmpb $0x0,0x12(%edi) 10b7af: 0f 84 3b 01 00 00 je 10b8f0 <_Objects_Extend_information+0x298> information->object_blocks[ block ] = 10b7b5: c1 e3 02 shl $0x2,%ebx 10b7b8: 89 5d dc mov %ebx,-0x24(%ebp) 10b7bb: 03 5f 34 add 0x34(%edi),%ebx 10b7be: 83 ec 0c sub $0xc,%esp 10b7c1: 8b 45 a8 mov -0x58(%ebp),%eax 10b7c4: 0f af 47 18 imul 0x18(%edi),%eax 10b7c8: 50 push %eax 10b7c9: e8 52 1c 00 00 call 10d420 <_Workspace_Allocate> 10b7ce: 89 03 mov %eax,(%ebx) _Workspace_Allocate( (information->allocation_size * information->size) ); if ( !information->object_blocks[ block ] ) 10b7d0: 8b 47 34 mov 0x34(%edi),%eax 10b7d3: 8b 55 dc mov -0x24(%ebp),%edx 10b7d6: 8b 04 10 mov (%eax,%edx,1),%eax 10b7d9: 83 c4 10 add $0x10,%esp 10b7dc: 85 c0 test %eax,%eax 10b7de: 74 7a je 10b85a <_Objects_Extend_information+0x202><== NEVER TAKEN /* * Initialize objects .. add to a local chain first. */ _Chain_Initialize( 10b7e0: 8b 4d 08 mov 0x8(%ebp),%ecx 10b7e3: ff 71 18 pushl 0x18(%ecx) 10b7e6: ff 71 14 pushl 0x14(%ecx) 10b7e9: 50 push %eax 10b7ea: 8d 75 e8 lea -0x18(%ebp),%esi 10b7ed: 56 push %esi 10b7ee: e8 69 38 00 00 call 10f05c <_Chain_Initialize> information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10b7f3: 8b 75 08 mov 0x8(%ebp),%esi 10b7f6: 83 c6 20 add $0x20,%esi 10b7f9: 8b 5d c4 mov -0x3c(%ebp),%ebx 10b7fc: 83 c4 10 add $0x10,%esp 10b7ff: eb 2c jmp 10b82d <_Objects_Extend_information+0x1d5> 10b801: 8d 76 00 lea 0x0(%esi),%esi index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { the_object->id = _Objects_Build_id( 10b804: 8b 7d 08 mov 0x8(%ebp),%edi 10b807: 8b 07 mov (%edi),%eax 10b809: c1 e0 18 shl $0x18,%eax 10b80c: 0d 00 00 01 00 or $0x10000,%eax 10b811: 0f b7 57 04 movzwl 0x4(%edi),%edx 10b815: c1 e2 1b shl $0x1b,%edx 10b818: 09 d0 or %edx,%eax 10b81a: 09 d8 or %ebx,%eax 10b81c: 89 41 08 mov %eax,0x8(%ecx) information->the_class, _Objects_Local_node, index ); _Chain_Append( &information->Inactive, &the_object->Node ); 10b81f: 83 ec 08 sub $0x8,%esp 10b822: 51 push %ecx 10b823: 56 push %esi 10b824: e8 53 f5 ff ff call 10ad7c <_Chain_Append> index++; 10b829: 43 inc %ebx 10b82a: 83 c4 10 add $0x10,%esp * Move from the local chain, initialise, then append to the inactive chain */ index = index_base; while ( (the_object = (Objects_Control *) _Chain_Get( &Inactive ) ) != NULL ) { 10b82d: 83 ec 0c sub $0xc,%esp 10b830: 8d 45 e8 lea -0x18(%ebp),%eax 10b833: 50 push %eax 10b834: e8 67 f5 ff ff call 10ada0 <_Chain_Get> 10b839: 89 c1 mov %eax,%ecx 10b83b: 83 c4 10 add $0x10,%esp 10b83e: 85 c0 test %eax,%eax 10b840: 75 c2 jne 10b804 <_Objects_Extend_information+0x1ac> _Chain_Append( &information->Inactive, &the_object->Node ); index++; } information->inactive_per_block[ block ] = information->allocation_size; 10b842: 8b 55 08 mov 0x8(%ebp),%edx 10b845: 8b 42 30 mov 0x30(%edx),%eax 10b848: 89 d1 mov %edx,%ecx 10b84a: 8b 52 14 mov 0x14(%edx),%edx 10b84d: 8b 75 dc mov -0x24(%ebp),%esi 10b850: 89 14 30 mov %edx,(%eax,%esi,1) information->inactive += information->allocation_size; 10b853: 8b 41 14 mov 0x14(%ecx),%eax 10b856: 66 01 41 2c add %ax,0x2c(%ecx) } 10b85a: 8d 65 f4 lea -0xc(%ebp),%esp 10b85d: 5b pop %ebx 10b85e: 5e pop %esi 10b85f: 5f pop %edi 10b860: c9 leave 10b861: c3 ret 10b862: 66 90 xchg %ax,%ax block = 0; if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; 10b864: 8b 7d 08 mov 0x8(%ebp),%edi 10b867: 8b 7f 14 mov 0x14(%edi),%edi 10b86a: 89 7d a8 mov %edi,-0x58(%ebp) 10b86d: 89 f0 mov %esi,%eax 10b86f: 31 d2 xor %edx,%edx 10b871: f7 f7 div %edi 10b873: 89 45 a4 mov %eax,-0x5c(%ebp) 10b876: 89 45 c0 mov %eax,-0x40(%ebp) for ( ; block < block_count; block++ ) { 10b879: 85 c0 test %eax,%eax 10b87b: 0f 84 e6 00 00 00 je 10b967 <_Objects_Extend_information+0x30f><== NEVER TAKEN if ( information->object_blocks[ block ] == NULL ) 10b881: 8b 7d 08 mov 0x8(%ebp),%edi 10b884: 8b 4f 34 mov 0x34(%edi),%ecx 10b887: 8b 19 mov (%ecx),%ebx 10b889: 85 db test %ebx,%ebx 10b88b: 0f 84 d6 00 00 00 je 10b967 <_Objects_Extend_information+0x30f><== NEVER TAKEN 10b891: 8b 45 c8 mov -0x38(%ebp),%eax 10b894: 89 45 c4 mov %eax,-0x3c(%ebp) 10b897: 31 db xor %ebx,%ebx 10b899: eb 08 jmp 10b8a3 <_Objects_Extend_information+0x24b> 10b89b: 90 nop 10b89c: 8b 14 99 mov (%ecx,%ebx,4),%edx 10b89f: 85 d2 test %edx,%edx 10b8a1: 74 0c je 10b8af <_Objects_Extend_information+0x257> break; else index_base += information->allocation_size; 10b8a3: 8b 55 a8 mov -0x58(%ebp),%edx 10b8a6: 01 55 c4 add %edx,-0x3c(%ebp) if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10b8a9: 43 inc %ebx 10b8aa: 39 5d a4 cmp %ebx,-0x5c(%ebp) 10b8ad: 77 ed ja 10b89c <_Objects_Extend_information+0x244> /* * If the index_base is the maximum we need to grow the tables. */ if (index_base >= information->maximum ) { 10b8af: 39 75 c4 cmp %esi,-0x3c(%ebp) 10b8b2: 0f 82 f0 fe ff ff jb 10b7a8 <_Objects_Extend_information+0x150> 10b8b8: 8b 7d a4 mov -0x5c(%ebp),%edi 10b8bb: 47 inc %edi 10b8bc: 89 7d e0 mov %edi,-0x20(%ebp) 10b8bf: 8d 14 7f lea (%edi,%edi,2),%edx 10b8c2: e9 d2 fd ff ff jmp 10b699 <_Objects_Extend_information+0x41> 10b8c7: 90 nop /* * Allocate the tables and break it up. */ if ( information->auto_extend ) { object_blocks = (void**) 10b8c8: 83 ec 0c sub $0xc,%esp 10b8cb: 8b 4d c8 mov -0x38(%ebp),%ecx 10b8ce: 8d 04 0a lea (%edx,%ecx,1),%eax 10b8d1: 01 f0 add %esi,%eax 10b8d3: c1 e0 02 shl $0x2,%eax 10b8d6: 50 push %eax 10b8d7: e8 44 1b 00 00 call 10d420 <_Workspace_Allocate> 10b8dc: 89 45 cc mov %eax,-0x34(%ebp) block_count * (sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) + ((maximum + minimum_index) * sizeof(Objects_Control *)) ); if ( !object_blocks ) 10b8df: 83 c4 10 add $0x10,%esp 10b8e2: 85 c0 test %eax,%eax 10b8e4: 0f 85 dd fd ff ff jne 10b6c7 <_Objects_Extend_information+0x6f><== ALWAYS TAKEN 10b8ea: e9 6b ff ff ff jmp 10b85a <_Objects_Extend_information+0x202><== NOT EXECUTED 10b8ef: 90 nop <== NOT EXECUTED if ( !information->object_blocks[ block ] ) return; } else { information->object_blocks[ block ] = 10b8f0: c1 e3 02 shl $0x2,%ebx 10b8f3: 89 5d dc mov %ebx,-0x24(%ebp) 10b8f6: 8b 4d 08 mov 0x8(%ebp),%ecx 10b8f9: 03 59 34 add 0x34(%ecx),%ebx 10b8fc: 83 ec 0c sub $0xc,%esp 10b8ff: 8b 75 a8 mov -0x58(%ebp),%esi 10b902: 0f af 71 18 imul 0x18(%ecx),%esi 10b906: 56 push %esi 10b907: e8 2c 1b 00 00 call 10d438 <_Workspace_Allocate_or_fatal_error> 10b90c: 89 03 mov %eax,(%ebx) 10b90e: 8b 7d 08 mov 0x8(%ebp),%edi 10b911: 8b 47 34 mov 0x34(%edi),%eax 10b914: 8b 55 dc mov -0x24(%ebp),%edx 10b917: 8b 04 10 mov (%eax,%edx,1),%eax 10b91a: 83 c4 10 add $0x10,%esp 10b91d: e9 be fe ff ff jmp 10b7e0 <_Objects_Extend_information+0x188> 10b922: 66 90 xchg %ax,%ax /* * 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, 10b924: 8b 45 c0 mov -0x40(%ebp),%eax 10b927: c1 e0 02 shl $0x2,%eax 10b92a: 8b 7d 08 mov 0x8(%ebp),%edi 10b92d: 8b 77 34 mov 0x34(%edi),%esi 10b930: 8b 7d cc mov -0x34(%ebp),%edi 10b933: 89 c1 mov %eax,%ecx 10b935: f3 a4 rep movsb %ds:(%esi),%es:(%edi) information->object_blocks, block_count * sizeof(void*) ); memcpy( inactive_per_block, 10b937: 8b 55 08 mov 0x8(%ebp),%edx 10b93a: 8b 72 30 mov 0x30(%edx),%esi 10b93d: 8b 7d d0 mov -0x30(%ebp),%edi 10b940: 89 c1 mov %eax,%ecx 10b942: f3 a4 rep movsb %ds:(%esi),%es:(%edi) information->inactive_per_block, block_count * sizeof(uint32_t) ); memcpy( local_table, 10b944: 0f b7 4a 10 movzwl 0x10(%edx),%ecx 10b948: 03 4d c8 add -0x38(%ebp),%ecx 10b94b: c1 e1 02 shl $0x2,%ecx 10b94e: 8b 72 1c mov 0x1c(%edx),%esi 10b951: 8b 7d d8 mov -0x28(%ebp),%edi 10b954: f3 a4 rep movsb %ds:(%esi),%es:(%edi) 10b956: e9 ad fd ff ff jmp 10b708 <_Objects_Extend_information+0xb0> 10b95b: 90 nop information->maximum ); _ISR_Enable( level ); if ( old_tables ) 10b95c: 8b 4f 14 mov 0x14(%edi),%ecx 10b95f: 89 4d a8 mov %ecx,-0x58(%ebp) 10b962: e9 41 fe ff ff jmp 10b7a8 <_Objects_Extend_information+0x150> if ( information->maximum < minimum_index ) block_count = 0; else { block_count = information->maximum / information->allocation_size; for ( ; block < block_count; block++ ) { 10b967: 8b 4d c8 mov -0x38(%ebp),%ecx <== NOT EXECUTED 10b96a: 89 4d c4 mov %ecx,-0x3c(%ebp) <== NOT EXECUTED 10b96d: 31 db xor %ebx,%ebx <== NOT EXECUTED 10b96f: e9 3b ff ff ff jmp 10b8af <_Objects_Extend_information+0x257><== NOT EXECUTED =============================================================================== 0010b974 <_Objects_Free>: void _Objects_Free( Objects_Information *information, Objects_Control *the_object ) { 10b974: 55 push %ebp 10b975: 89 e5 mov %esp,%ebp 10b977: 57 push %edi 10b978: 56 push %esi 10b979: 53 push %ebx 10b97a: 83 ec 14 sub $0x14,%esp 10b97d: 8b 5d 08 mov 0x8(%ebp),%ebx 10b980: 8b 75 0c mov 0xc(%ebp),%esi uint32_t allocation_size = information->allocation_size; 10b983: 8b 7b 14 mov 0x14(%ebx),%edi _Chain_Append( &information->Inactive, &the_object->Node ); 10b986: 56 push %esi 10b987: 8d 43 20 lea 0x20(%ebx),%eax 10b98a: 50 push %eax 10b98b: e8 ec f3 ff ff call 10ad7c <_Chain_Append> if ( information->auto_extend ) { 10b990: 83 c4 10 add $0x10,%esp 10b993: 80 7b 12 00 cmpb $0x0,0x12(%ebx) 10b997: 74 35 je 10b9ce <_Objects_Free+0x5a> uint32_t block; block = 10b999: 8b 46 08 mov 0x8(%esi),%eax 10b99c: 25 ff ff 00 00 and $0xffff,%eax 10b9a1: 8b 53 08 mov 0x8(%ebx),%edx 10b9a4: 81 e2 ff ff 00 00 and $0xffff,%edx 10b9aa: 29 d0 sub %edx,%eax _Objects_Get_index( the_object->id ) - _Objects_Get_index( information->minimum_id ); block /= information->allocation_size; information->inactive_per_block[ block ]++; 10b9ac: 31 d2 xor %edx,%edx 10b9ae: f7 73 14 divl 0x14(%ebx) 10b9b1: c1 e0 02 shl $0x2,%eax 10b9b4: 03 43 30 add 0x30(%ebx),%eax 10b9b7: ff 00 incl (%eax) information->inactive++; 10b9b9: 8b 53 2c mov 0x2c(%ebx),%edx 10b9bc: 42 inc %edx 10b9bd: 66 89 53 2c mov %dx,0x2c(%ebx) /* * Check if the threshold level has been met of * 1.5 x allocation_size are free. */ if ( information->inactive > ( allocation_size + ( allocation_size >> 1 ) ) ) { 10b9c1: 0f b7 d2 movzwl %dx,%edx 10b9c4: 89 f8 mov %edi,%eax 10b9c6: d1 e8 shr %eax 10b9c8: 01 f8 add %edi,%eax 10b9ca: 39 c2 cmp %eax,%edx 10b9cc: 77 0a ja 10b9d8 <_Objects_Free+0x64> _Objects_Shrink_information( information ); } } } 10b9ce: 8d 65 f4 lea -0xc(%ebp),%esp 10b9d1: 5b pop %ebx 10b9d2: 5e pop %esi 10b9d3: 5f pop %edi 10b9d4: c9 leave 10b9d5: c3 ret 10b9d6: 66 90 xchg %ax,%ax * 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 ); 10b9d8: 89 5d 08 mov %ebx,0x8(%ebp) } } } 10b9db: 8d 65 f4 lea -0xc(%ebp),%esp 10b9de: 5b pop %ebx 10b9df: 5e pop %esi 10b9e0: 5f pop %edi 10b9e1: c9 leave * 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 ); 10b9e2: e9 a5 02 00 00 jmp 10bc8c <_Objects_Shrink_information> =============================================================================== 0010baa8 <_Objects_Get>: Objects_Control *_Objects_Get( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 10baa8: 55 push %ebp 10baa9: 89 e5 mov %esp,%ebp 10baab: 53 push %ebx 10baac: 83 ec 04 sub $0x4,%esp 10baaf: 8b 4d 08 mov 0x8(%ebp),%ecx * 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; 10bab2: ba 01 00 00 00 mov $0x1,%edx 10bab7: 2b 51 08 sub 0x8(%ecx),%edx 10baba: 03 55 0c add 0xc(%ebp),%edx /* * 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 ) { 10babd: 0f b7 41 10 movzwl 0x10(%ecx),%eax 10bac1: 39 c2 cmp %eax,%edx 10bac3: 77 27 ja 10baec <_Objects_Get+0x44> /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10bac5: a1 58 e6 11 00 mov 0x11e658,%eax 10baca: 40 inc %eax 10bacb: a3 58 e6 11 00 mov %eax,0x11e658 _Thread_Disable_dispatch(); if ( (the_object = information->local_table[ index ]) != NULL ) { 10bad0: 8b 41 1c mov 0x1c(%ecx),%eax 10bad3: 8b 1c 90 mov (%eax,%edx,4),%ebx 10bad6: 85 db test %ebx,%ebx 10bad8: 74 1f je 10baf9 <_Objects_Get+0x51> *location = OBJECTS_LOCAL; 10bada: 8b 45 10 mov 0x10(%ebp),%eax 10badd: c7 00 00 00 00 00 movl $0x0,(%eax) _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10bae3: 89 d8 mov %ebx,%eax 10bae5: 5a pop %edx 10bae6: 5b pop %ebx 10bae7: c9 leave 10bae8: c3 ret 10bae9: 8d 76 00 lea 0x0(%esi),%esi /* * 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; 10baec: 8b 45 10 mov 0x10(%ebp),%eax 10baef: c7 00 01 00 00 00 movl $0x1,(%eax) 10baf5: 31 db xor %ebx,%ebx 10baf7: eb ea jmp 10bae3 <_Objects_Get+0x3b> /* * Valid Id for this API, Class and Node but the object has not * been allocated yet. */ _Thread_Enable_dispatch(); 10baf9: e8 ee 07 00 00 call 10c2ec <_Thread_Enable_dispatch> *location = OBJECTS_ERROR; 10bafe: 8b 45 10 mov 0x10(%ebp),%eax 10bb01: c7 00 01 00 00 00 movl $0x1,(%eax) 10bb07: eb da jmp 10bae3 <_Objects_Get+0x3b> =============================================================================== 0010ba08 <_Objects_Get_information>: Objects_Information *_Objects_Get_information( Objects_APIs the_api, uint32_t the_class ) { 10ba08: 55 push %ebp 10ba09: 89 e5 mov %esp,%ebp 10ba0b: 53 push %ebx 10ba0c: 83 ec 04 sub $0x4,%esp 10ba0f: 8b 5d 08 mov 0x8(%ebp),%ebx /** * 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. 10ba12: 8d 43 ff lea -0x1(%ebx),%eax 10ba15: 83 f8 03 cmp $0x3,%eax 10ba18: 77 07 ja 10ba21 <_Objects_Get_information+0x19> int the_class_api_maximum; if ( !_Objects_Is_api_valid( the_api ) ) return NULL; if ( !the_class ) 10ba1a: 8b 45 0c mov 0xc(%ebp),%eax 10ba1d: 85 c0 test %eax,%eax 10ba1f: 75 07 jne 10ba28 <_Objects_Get_information+0x20> * 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 ) 10ba21: 31 c0 xor %eax,%eax return NULL; #endif return info; } 10ba23: 8b 5d fc mov -0x4(%ebp),%ebx 10ba26: c9 leave 10ba27: c3 ret return NULL; if ( !the_class ) return NULL; the_class_api_maximum = _Objects_API_maximum_class( the_api ); 10ba28: 83 ec 0c sub $0xc,%esp 10ba2b: 53 push %ebx 10ba2c: e8 8b 3a 00 00 call 10f4bc <_Objects_API_maximum_class> if ( the_class_api_maximum < 0 || 10ba31: 83 c4 10 add $0x10,%esp 10ba34: 85 c0 test %eax,%eax 10ba36: 78 e9 js 10ba21 <_Objects_Get_information+0x19><== NEVER TAKEN 10ba38: 39 45 0c cmp %eax,0xc(%ebp) 10ba3b: 77 e4 ja 10ba21 <_Objects_Get_information+0x19><== NEVER TAKEN the_class > (uint32_t) the_class_api_maximum ) return NULL; if ( !_Objects_Information_table[ the_api ] ) 10ba3d: 8b 04 9d 2c e6 11 00 mov 0x11e62c(,%ebx,4),%eax 10ba44: 85 c0 test %eax,%eax 10ba46: 74 d9 je 10ba21 <_Objects_Get_information+0x19><== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 10ba48: 8b 55 0c mov 0xc(%ebp),%edx 10ba4b: 8b 04 90 mov (%eax,%edx,4),%eax if ( !info ) 10ba4e: 85 c0 test %eax,%eax 10ba50: 74 d1 je 10ba23 <_Objects_Get_information+0x1b><== NEVER TAKEN * 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 ) 10ba52: 66 83 78 10 00 cmpw $0x0,0x10(%eax) 10ba57: 75 ca jne 10ba23 <_Objects_Get_information+0x1b> 10ba59: eb c6 jmp 10ba21 <_Objects_Get_information+0x19> =============================================================================== 0010ba5c <_Objects_Get_isr_disable>: Objects_Information *information, Objects_Id id, Objects_Locations *location, ISR_Level *level_p ) { 10ba5c: 55 push %ebp 10ba5d: 89 e5 mov %esp,%ebp 10ba5f: 56 push %esi 10ba60: 53 push %ebx 10ba61: 8b 5d 08 mov 0x8(%ebp),%ebx 10ba64: 8b 75 10 mov 0x10(%ebp),%esi #if defined(RTEMS_MULTIPROCESSING) index = id - information->minimum_id + 1; #else /* index = _Objects_Get_index( id ); */ index = id & 0x0000ffff; 10ba67: 0f b7 55 0c movzwl 0xc(%ebp),%edx /* This should work but doesn't always :( */ /* index = (uint16_t ) id; */ #endif _ISR_Disable( level ); 10ba6b: 9c pushf 10ba6c: fa cli 10ba6d: 59 pop %ecx if ( information->maximum >= index ) { 10ba6e: 0f b7 43 10 movzwl 0x10(%ebx),%eax 10ba72: 39 c2 cmp %eax,%edx 10ba74: 77 1a ja 10ba90 <_Objects_Get_isr_disable+0x34> if ( (the_object = information->local_table[ index ]) != NULL ) { 10ba76: 8b 43 1c mov 0x1c(%ebx),%eax 10ba79: 8b 04 90 mov (%eax,%edx,4),%eax 10ba7c: 85 c0 test %eax,%eax 10ba7e: 74 1c je 10ba9c <_Objects_Get_isr_disable+0x40><== NEVER TAKEN *location = OBJECTS_LOCAL; 10ba80: c7 06 00 00 00 00 movl $0x0,(%esi) *level_p = level; 10ba86: 8b 55 14 mov 0x14(%ebp),%edx 10ba89: 89 0a mov %ecx,(%edx) _Objects_MP_Is_remote( information, id, location, &the_object ); return the_object; #else return NULL; #endif } 10ba8b: 5b pop %ebx 10ba8c: 5e pop %esi 10ba8d: c9 leave 10ba8e: c3 ret 10ba8f: 90 nop } _ISR_Enable( level ); *location = OBJECTS_ERROR; return NULL; } _ISR_Enable( level ); 10ba90: 51 push %ecx 10ba91: 9d popf *location = OBJECTS_ERROR; 10ba92: c7 06 01 00 00 00 movl $0x1,(%esi) 10ba98: 31 c0 xor %eax,%eax 10ba9a: eb ef jmp 10ba8b <_Objects_Get_isr_disable+0x2f> if ( (the_object = information->local_table[ index ]) != NULL ) { *location = OBJECTS_LOCAL; *level_p = level; return the_object; } _ISR_Enable( level ); 10ba9c: 51 push %ecx <== NOT EXECUTED 10ba9d: 9d popf <== NOT EXECUTED *location = OBJECTS_ERROR; 10ba9e: c7 06 01 00 00 00 movl $0x1,(%esi) <== NOT EXECUTED 10baa4: eb e5 jmp 10ba8b <_Objects_Get_isr_disable+0x2f><== NOT EXECUTED =============================================================================== 0010ce74 <_Objects_Get_name_as_string>: char *_Objects_Get_name_as_string( Objects_Id id, size_t length, char *name ) { 10ce74: 55 push %ebp 10ce75: 89 e5 mov %esp,%ebp 10ce77: 57 push %edi 10ce78: 56 push %esi 10ce79: 53 push %ebx 10ce7a: 83 ec 1c sub $0x1c,%esp 10ce7d: 8b 75 0c mov 0xc(%ebp),%esi 10ce80: 8b 5d 10 mov 0x10(%ebp),%ebx char lname[5]; Objects_Control *the_object; Objects_Locations location; Objects_Id tmpId; if ( length == 0 ) 10ce83: 85 f6 test %esi,%esi 10ce85: 75 0d jne 10ce94 <_Objects_Get_name_as_string+0x20> } } *d = '\0'; _Thread_Enable_dispatch(); return name; 10ce87: 31 db xor %ebx,%ebx } return NULL; /* unreachable path */ } 10ce89: 89 d8 mov %ebx,%eax 10ce8b: 8d 65 f4 lea -0xc(%ebp),%esp 10ce8e: 5b pop %ebx 10ce8f: 5e pop %esi 10ce90: 5f pop %edi 10ce91: c9 leave 10ce92: c3 ret 10ce93: 90 nop Objects_Id tmpId; if ( length == 0 ) return NULL; if ( name == NULL ) 10ce94: 85 db test %ebx,%ebx 10ce96: 74 f1 je 10ce89 <_Objects_Get_name_as_string+0x15> return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10ce98: 8b 7d 08 mov 0x8(%ebp),%edi 10ce9b: 85 ff test %edi,%edi 10ce9d: 0f 84 8d 00 00 00 je 10cf30 <_Objects_Get_name_as_string+0xbc> 10cea3: 8b 45 08 mov 0x8(%ebp),%eax 10cea6: 89 45 e0 mov %eax,-0x20(%ebp) information = _Objects_Get_information_id( tmpId ); 10cea9: 83 ec 0c sub $0xc,%esp 10ceac: ff 75 e0 pushl -0x20(%ebp) 10ceaf: e8 00 ff ff ff call 10cdb4 <_Objects_Get_information_id> 10ceb4: 89 c7 mov %eax,%edi if ( !information ) 10ceb6: 83 c4 10 add $0x10,%esp 10ceb9: 85 c0 test %eax,%eax 10cebb: 74 ca je 10ce87 <_Objects_Get_name_as_string+0x13> return NULL; the_object = _Objects_Get( information, tmpId, &location ); 10cebd: 51 push %ecx 10cebe: 8d 45 f0 lea -0x10(%ebp),%eax 10cec1: 50 push %eax 10cec2: ff 75 e0 pushl -0x20(%ebp) 10cec5: 57 push %edi 10cec6: e8 a9 00 00 00 call 10cf74 <_Objects_Get> switch ( location ) { 10cecb: 83 c4 10 add $0x10,%esp 10cece: 8b 55 f0 mov -0x10(%ebp),%edx 10ced1: 85 d2 test %edx,%edx 10ced3: 75 b2 jne 10ce87 <_Objects_Get_name_as_string+0x13> case OBJECTS_ERROR: return NULL; case OBJECTS_LOCAL: if ( information->is_string ) { 10ced5: 80 7f 38 00 cmpb $0x0,0x38(%edi) 10ced9: 74 65 je 10cf40 <_Objects_Get_name_as_string+0xcc> s = the_object->name.name_p; 10cedb: 8b 40 0c mov 0xc(%eax),%eax 10cede: 89 45 dc mov %eax,-0x24(%ebp) lname[ 4 ] = '\0'; s = lname; } d = name; if ( s ) { 10cee1: 85 c0 test %eax,%eax 10cee3: 0f 84 84 00 00 00 je 10cf6d <_Objects_Get_name_as_string+0xf9><== NEVER TAKEN for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 10cee9: 4e dec %esi 10ceea: 89 75 d8 mov %esi,-0x28(%ebp) 10ceed: 74 7e je 10cf6d <_Objects_Get_name_as_string+0xf9><== NEVER TAKEN 10ceef: 8b 45 dc mov -0x24(%ebp),%eax 10cef2: 8a 08 mov (%eax),%cl 10cef4: 84 c9 test %cl,%cl 10cef6: 74 75 je 10cf6d <_Objects_Get_name_as_string+0xf9> 10cef8: 89 df mov %ebx,%edi 10cefa: 31 f6 xor %esi,%esi 10cefc: eb 0c jmp 10cf0a <_Objects_Get_name_as_string+0x96> 10cefe: 66 90 xchg %ax,%ax 10cf00: 8b 45 dc mov -0x24(%ebp),%eax 10cf03: 8a 0c 30 mov (%eax,%esi,1),%cl 10cf06: 84 c9 test %cl,%cl 10cf08: 74 19 je 10cf23 <_Objects_Get_name_as_string+0xaf> *d = (isprint(*s)) ? *s : '*'; 10cf0a: 0f be d1 movsbl %cl,%edx 10cf0d: a1 c8 07 12 00 mov 0x1207c8,%eax 10cf12: f6 04 10 97 testb $0x97,(%eax,%edx,1) 10cf16: 75 02 jne 10cf1a <_Objects_Get_name_as_string+0xa6> 10cf18: b1 2a mov $0x2a,%cl 10cf1a: 88 0f mov %cl,(%edi) s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 10cf1c: 46 inc %esi 10cf1d: 47 inc %edi 10cf1e: 3b 75 d8 cmp -0x28(%ebp),%esi 10cf21: 72 dd jb 10cf00 <_Objects_Get_name_as_string+0x8c> *d = (isprint(*s)) ? *s : '*'; } } *d = '\0'; 10cf23: c6 07 00 movb $0x0,(%edi) _Thread_Enable_dispatch(); 10cf26: e8 8d 08 00 00 call 10d7b8 <_Thread_Enable_dispatch> 10cf2b: e9 59 ff ff ff jmp 10ce89 <_Objects_Get_name_as_string+0x15> return NULL; if ( name == NULL ) return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10cf30: a1 3c a7 12 00 mov 0x12a73c,%eax 10cf35: 8b 40 08 mov 0x8(%eax),%eax 10cf38: 89 45 e0 mov %eax,-0x20(%ebp) 10cf3b: e9 69 ff ff ff jmp 10cea9 <_Objects_Get_name_as_string+0x35> 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; 10cf40: 8b 50 0c mov 0xc(%eax),%edx lname[ 0 ] = (u32_name >> 24) & 0xff; 10cf43: 89 d0 mov %edx,%eax 10cf45: c1 e8 18 shr $0x18,%eax 10cf48: 88 45 eb mov %al,-0x15(%ebp) lname[ 1 ] = (u32_name >> 16) & 0xff; 10cf4b: 89 d0 mov %edx,%eax 10cf4d: c1 e8 10 shr $0x10,%eax 10cf50: 88 45 ec mov %al,-0x14(%ebp) lname[ 2 ] = (u32_name >> 8) & 0xff; 10cf53: 89 d0 mov %edx,%eax 10cf55: c1 e8 08 shr $0x8,%eax 10cf58: 88 45 ed mov %al,-0x13(%ebp) lname[ 3 ] = (u32_name >> 0) & 0xff; 10cf5b: 88 55 ee mov %dl,-0x12(%ebp) lname[ 4 ] = '\0'; 10cf5e: c6 45 ef 00 movb $0x0,-0x11(%ebp) 10cf62: 8d 45 eb lea -0x15(%ebp),%eax 10cf65: 89 45 dc mov %eax,-0x24(%ebp) 10cf68: e9 7c ff ff ff jmp 10cee9 <_Objects_Get_name_as_string+0x75> s = lname; } d = name; if ( s ) { for ( i=0 ; i<(length-1) && *s ; i++, s++, d++ ) { 10cf6d: 89 df mov %ebx,%edi 10cf6f: eb b2 jmp 10cf23 <_Objects_Get_name_as_string+0xaf> =============================================================================== 00116ba0 <_Objects_Get_no_protection>: Objects_Control *_Objects_Get_no_protection( Objects_Information *information, Objects_Id id, Objects_Locations *location ) { 116ba0: 55 push %ebp 116ba1: 89 e5 mov %esp,%ebp 116ba3: 8b 4d 08 mov 0x8(%ebp),%ecx /* * 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; 116ba6: ba 01 00 00 00 mov $0x1,%edx 116bab: 2b 51 08 sub 0x8(%ecx),%edx 116bae: 03 55 0c add 0xc(%ebp),%edx if ( information->maximum >= index ) { 116bb1: 0f b7 41 10 movzwl 0x10(%ecx),%eax 116bb5: 39 c2 cmp %eax,%edx 116bb7: 77 17 ja 116bd0 <_Objects_Get_no_protection+0x30> if ( (the_object = information->local_table[ index ]) != NULL ) { 116bb9: 8b 41 1c mov 0x1c(%ecx),%eax 116bbc: 8b 04 90 mov (%eax,%edx,4),%eax 116bbf: 85 c0 test %eax,%eax 116bc1: 74 0d je 116bd0 <_Objects_Get_no_protection+0x30><== NEVER TAKEN *location = OBJECTS_LOCAL; 116bc3: 8b 55 10 mov 0x10(%ebp),%edx 116bc6: c7 02 00 00 00 00 movl $0x0,(%edx) * 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; } 116bcc: c9 leave 116bcd: c3 ret 116bce: 66 90 xchg %ax,%ax /* * This isn't supported or required yet for Global objects so * if it isn't local, we don't find it. */ *location = OBJECTS_ERROR; 116bd0: 8b 45 10 mov 0x10(%ebp),%eax 116bd3: c7 00 01 00 00 00 movl $0x1,(%eax) 116bd9: 31 c0 xor %eax,%eax return NULL; } 116bdb: c9 leave 116bdc: c3 ret =============================================================================== 0010cb3c <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 10cb3c: 55 push %ebp 10cb3d: 89 e5 mov %esp,%ebp 10cb3f: 53 push %ebx 10cb40: 83 ec 14 sub $0x14,%esp 10cb43: 8b 45 08 mov 0x8(%ebp),%eax 10cb46: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Id tmpId; Objects_Information *information; Objects_Control *the_object = (Objects_Control *) 0; Objects_Locations ignored_location; if ( !name ) 10cb49: 85 db test %ebx,%ebx 10cb4b: 74 7b je 10cbc8 <_Objects_Id_to_name+0x8c><== NEVER TAKEN return OBJECTS_INVALID_NAME; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10cb4d: 85 c0 test %eax,%eax 10cb4f: 74 53 je 10cba4 <_Objects_Id_to_name+0x68> 10cb51: 89 c1 mov %eax,%ecx uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10cb53: 89 ca mov %ecx,%edx 10cb55: c1 ea 18 shr $0x18,%edx 10cb58: 83 e2 07 and $0x7,%edx /** * 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. 10cb5b: 8d 42 ff lea -0x1(%edx),%eax 10cb5e: 83 f8 03 cmp $0x3,%eax 10cb61: 77 59 ja 10cbbc <_Objects_Id_to_name+0x80> the_api = _Objects_Get_API( tmpId ); if ( !_Objects_Is_api_valid( the_api ) ) return OBJECTS_INVALID_ID; if ( !_Objects_Information_table[ the_api ] ) 10cb63: 8b 14 95 8c 16 12 00 mov 0x12168c(,%edx,4),%edx 10cb6a: 85 d2 test %edx,%edx 10cb6c: 74 4e je 10cbbc <_Objects_Id_to_name+0x80><== NEVER TAKEN return OBJECTS_INVALID_ID; the_class = _Objects_Get_class( tmpId ); information = _Objects_Information_table[ the_api ][ the_class ]; 10cb6e: 89 c8 mov %ecx,%eax 10cb70: c1 e8 1b shr $0x1b,%eax 10cb73: 8b 14 82 mov (%edx,%eax,4),%edx if ( !information ) 10cb76: 85 d2 test %edx,%edx 10cb78: 74 42 je 10cbbc <_Objects_Id_to_name+0x80><== NEVER TAKEN return OBJECTS_INVALID_ID; if ( information->is_string ) 10cb7a: 80 7a 38 00 cmpb $0x0,0x38(%edx) 10cb7e: 75 3c jne 10cbbc <_Objects_Id_to_name+0x80><== NEVER TAKEN return OBJECTS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &ignored_location ); 10cb80: 50 push %eax 10cb81: 8d 45 f8 lea -0x8(%ebp),%eax 10cb84: 50 push %eax 10cb85: 51 push %ecx 10cb86: 52 push %edx 10cb87: e8 4c ff ff ff call 10cad8 <_Objects_Get> if ( !the_object ) 10cb8c: 83 c4 10 add $0x10,%esp 10cb8f: 85 c0 test %eax,%eax 10cb91: 74 29 je 10cbbc <_Objects_Id_to_name+0x80> return OBJECTS_INVALID_ID; *name = the_object->name; 10cb93: 8b 40 0c mov 0xc(%eax),%eax 10cb96: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 10cb98: e8 13 08 00 00 call 10d3b0 <_Thread_Enable_dispatch> 10cb9d: 31 c0 xor %eax,%eax return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 10cb9f: 8b 5d fc mov -0x4(%ebp),%ebx 10cba2: c9 leave 10cba3: c3 ret Objects_Locations ignored_location; if ( !name ) return OBJECTS_INVALID_NAME; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10cba4: a1 7c 17 12 00 mov 0x12177c,%eax 10cba9: 8b 48 08 mov 0x8(%eax),%ecx uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10cbac: 89 ca mov %ecx,%edx 10cbae: c1 ea 18 shr $0x18,%edx 10cbb1: 83 e2 07 and $0x7,%edx /** * 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. 10cbb4: 8d 42 ff lea -0x1(%edx),%eax 10cbb7: 83 f8 03 cmp $0x3,%eax 10cbba: 76 a7 jbe 10cb63 <_Objects_Id_to_name+0x27><== ALWAYS TAKEN if ( !the_object ) return OBJECTS_INVALID_ID; *name = the_object->name; _Thread_Enable_dispatch(); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 10cbbc: b8 03 00 00 00 mov $0x3,%eax } 10cbc1: 8b 5d fc mov -0x4(%ebp),%ebx 10cbc4: c9 leave 10cbc5: c3 ret 10cbc6: 66 90 xchg %ax,%ax Objects_Id tmpId; Objects_Information *information; Objects_Control *the_object = (Objects_Control *) 0; Objects_Locations ignored_location; if ( !name ) 10cbc8: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 10cbcd: eb f2 jmp 10cbc1 <_Objects_Id_to_name+0x85><== NOT EXECUTED =============================================================================== 0010bb0c <_Objects_Initialize_information>: , bool supports_global, Objects_Thread_queue_Extract_callout extract #endif ) { 10bb0c: 55 push %ebp 10bb0d: 89 e5 mov %esp,%ebp 10bb0f: 57 push %edi 10bb10: 56 push %esi 10bb11: 53 push %ebx 10bb12: 8b 7d 08 mov 0x8(%ebp),%edi 10bb15: 8b 55 0c mov 0xc(%ebp),%edx 10bb18: 8b 5d 10 mov 0x10(%ebp),%ebx 10bb1b: 8b 75 20 mov 0x20(%ebp),%esi 10bb1e: 0f b7 4d 18 movzwl 0x18(%ebp),%ecx uint32_t name_length; #if defined(RTEMS_MULTIPROCESSING) uint32_t index; #endif information->the_api = the_api; 10bb22: 89 17 mov %edx,(%edi) information->the_class = the_class; 10bb24: 66 89 5f 04 mov %bx,0x4(%edi) information->is_string = is_string; 10bb28: 8b 45 1c mov 0x1c(%ebp),%eax 10bb2b: 88 47 38 mov %al,0x38(%edi) information->local_table = 0; information->inactive_per_block = 0; 10bb2e: c7 47 30 00 00 00 00 movl $0x0,0x30(%edi) information->object_blocks = 0; 10bb35: c7 47 34 00 00 00 00 movl $0x0,0x34(%edi) information->inactive = 0; 10bb3c: 66 c7 47 2c 00 00 movw $0x0,0x2c(%edi) /* * Set the entry in the object information table. */ _Objects_Information_table[ the_api ][ the_class ] = information; 10bb42: 8b 04 95 2c e6 11 00 mov 0x11e62c(,%edx,4),%eax 10bb49: 89 3c 98 mov %edi,(%eax,%ebx,4) /* * Set the size of the object */ information->size = size; 10bb4c: 89 4f 18 mov %ecx,0x18(%edi) /* * Are we operating in unlimited, or auto-extend mode */ information->auto_extend = 10bb4f: 8b 45 14 mov 0x14(%ebp),%eax 10bb52: c1 e8 1f shr $0x1f,%eax 10bb55: 88 47 12 mov %al,0x12(%edi) (maximum & OBJECTS_UNLIMITED_OBJECTS) ? TRUE : FALSE; maximum &= ~OBJECTS_UNLIMITED_OBJECTS; 10bb58: 8b 4d 14 mov 0x14(%ebp),%ecx 10bb5b: 81 e1 ff ff ff 7f and $0x7fffffff,%ecx /* * The allocation unit is the maximum value */ information->allocation_size = maximum; 10bb61: 89 4f 14 mov %ecx,0x14(%edi) /* * Provide a null local table entry for the case of any empty table. */ information->local_table = &null_local_table; 10bb64: c7 47 1c c4 e3 11 00 movl $0x11e3c4,0x1c(%edi) */ if ( maximum == 0 ) minimum_index = 0; else minimum_index = 1; information->minimum_id = 10bb6b: c1 e2 18 shl $0x18,%edx 10bb6e: 81 ca 00 00 01 00 or $0x10000,%edx 10bb74: c1 e3 1b shl $0x1b,%ebx 10bb77: 09 da or %ebx,%edx 10bb79: 31 c0 xor %eax,%eax 10bb7b: 85 c9 test %ecx,%ecx 10bb7d: 0f 95 c0 setne %al 10bb80: 09 c2 or %eax,%edx 10bb82: 89 57 08 mov %edx,0x8(%edi) * Calculate the maximum name length */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) 10bb85: f7 c6 03 00 00 00 test $0x3,%esi 10bb8b: 75 23 jne 10bbb0 <_Objects_Initialize_information+0xa4><== NEVER TAKEN 10bb8d: 89 f0 mov %esi,%eax name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & ~(OBJECTS_NAME_ALIGNMENT-1); information->name_length = name_length; 10bb8f: 66 89 47 3a mov %ax,0x3a(%edi) 10bb93: 8d 47 24 lea 0x24(%edi),%eax 10bb96: 89 47 20 mov %eax,0x20(%edi) 10bb99: c7 47 24 00 00 00 00 movl $0x0,0x24(%edi) 10bba0: 8d 47 20 lea 0x20(%edi),%eax 10bba3: 89 47 28 mov %eax,0x28(%edi) /* * Initialize objects .. if there are any */ if ( maximum ) { 10bba6: 85 c9 test %ecx,%ecx 10bba8: 75 0e jne 10bbb8 <_Objects_Initialize_information+0xac> _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10bbaa: 5b pop %ebx 10bbab: 5e pop %esi 10bbac: 5f pop %edi 10bbad: c9 leave 10bbae: c3 ret 10bbaf: 90 nop */ name_length = maximum_name_length; if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) ) name_length = (name_length + OBJECTS_NAME_ALIGNMENT) & 10bbb0: 8d 46 04 lea 0x4(%esi),%eax <== NOT EXECUTED 10bbb3: 83 e0 fc and $0xfffffffc,%eax <== NOT EXECUTED 10bbb6: eb d7 jmp 10bb8f <_Objects_Initialize_information+0x83><== NOT EXECUTED /* * Reset the maximum value. It will be updated when the information is * extended. */ information->maximum = 0; 10bbb8: 66 c7 47 10 00 00 movw $0x0,0x10(%edi) * 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 ); 10bbbe: 89 7d 08 mov %edi,0x8(%ebp) _Chain_Initialize_empty( &information->global_table[ index ] ); } else information->global_table = NULL; #endif } 10bbc1: 5b pop %ebx 10bbc2: 5e pop %esi 10bbc3: 5f pop %edi 10bbc4: c9 leave * 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 ); 10bbc5: e9 8e fa ff ff jmp 10b658 <_Objects_Extend_information> =============================================================================== 0010bc00 <_Objects_Name_to_id_u32>: Objects_Information *information, uint32_t name, uint32_t node, Objects_Id *id ) { 10bc00: 55 push %ebp 10bc01: 89 e5 mov %esp,%ebp 10bc03: 57 push %edi 10bc04: 56 push %esi 10bc05: 53 push %ebx 10bc06: 8b 75 0c mov 0xc(%ebp),%esi 10bc09: 8b 7d 14 mov 0x14(%ebp),%edi Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == FALSE */ if ( !id ) 10bc0c: 85 ff test %edi,%edi 10bc0e: 74 5c je 10bc6c <_Objects_Name_to_id_u32+0x6c> return OBJECTS_INVALID_ADDRESS; if ( name == 0 ) 10bc10: 85 f6 test %esi,%esi 10bc12: 74 38 je 10bc4c <_Objects_Name_to_id_u32+0x4c> return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10bc14: 8b 55 08 mov 0x8(%ebp),%edx 10bc17: 8b 42 10 mov 0x10(%edx),%eax 10bc1a: 66 85 c0 test %ax,%ax 10bc1d: 74 2d je 10bc4c <_Objects_Name_to_id_u32+0x4c><== NEVER TAKEN 10bc1f: 8b 55 10 mov 0x10(%ebp),%edx 10bc22: 85 d2 test %edx,%edx 10bc24: 75 32 jne 10bc58 <_Objects_Name_to_id_u32+0x58> search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 10bc26: 0f b7 d8 movzwl %ax,%ebx 10bc29: 85 db test %ebx,%ebx 10bc2b: 74 1f je 10bc4c <_Objects_Name_to_id_u32+0x4c><== NEVER TAKEN if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10bc2d: 8b 45 08 mov 0x8(%ebp),%eax 10bc30: 8b 48 1c mov 0x1c(%eax),%ecx 10bc33: ba 01 00 00 00 mov $0x1,%edx if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { the_object = information->local_table[ index ]; 10bc38: 8b 04 91 mov (%ecx,%edx,4),%eax if ( !the_object ) 10bc3b: 85 c0 test %eax,%eax 10bc3d: 74 05 je 10bc44 <_Objects_Name_to_id_u32+0x44> continue; if ( name == the_object->name.name_u32 ) { 10bc3f: 39 70 0c cmp %esi,0xc(%eax) 10bc42: 74 34 je 10bc78 <_Objects_Name_to_id_u32+0x78> search_local_node = TRUE; if ( search_local_node ) { name_length = information->name_length; for ( index = 1; index <= information->maximum; index++ ) { 10bc44: 42 inc %edx 10bc45: 39 da cmp %ebx,%edx 10bc47: 76 ef jbe 10bc38 <_Objects_Name_to_id_u32+0x38> 10bc49: 8d 76 00 lea 0x0(%esi),%esi 10bc4c: b8 01 00 00 00 mov $0x1,%eax name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif } 10bc51: 5b pop %ebx 10bc52: 5e pop %esi 10bc53: 5f pop %edi 10bc54: c9 leave 10bc55: c3 ret 10bc56: 66 90 xchg %ax,%ax if ( name == 0 ) return OBJECTS_INVALID_NAME; search_local_node = FALSE; if ( information->maximum != 0 && 10bc58: 81 7d 10 ff ff ff 7f cmpl $0x7fffffff,0x10(%ebp) 10bc5f: 74 c5 je 10bc26 <_Objects_Name_to_id_u32+0x26> 10bc61: 83 7d 10 01 cmpl $0x1,0x10(%ebp) 10bc65: 75 e5 jne 10bc4c <_Objects_Name_to_id_u32+0x4c> 10bc67: eb bd jmp 10bc26 <_Objects_Name_to_id_u32+0x26> 10bc69: 8d 76 00 lea 0x0(%esi),%esi Objects_Name name_for_mp; #endif /* ASSERT: information->is_string == FALSE */ if ( !id ) 10bc6c: b8 02 00 00 00 mov $0x2,%eax name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif } 10bc71: 5b pop %ebx 10bc72: 5e pop %esi 10bc73: 5f pop %edi 10bc74: c9 leave 10bc75: c3 ret 10bc76: 66 90 xchg %ax,%ax the_object = information->local_table[ index ]; if ( !the_object ) continue; if ( name == the_object->name.name_u32 ) { *id = the_object->id; 10bc78: 8b 40 08 mov 0x8(%eax),%eax 10bc7b: 89 07 mov %eax,(%edi) 10bc7d: 31 c0 xor %eax,%eax name_for_mp.name_u32 = name; return _Objects_MP_Global_name_search( information, name_for_mp, node, id ); #else return OBJECTS_INVALID_NAME; #endif } 10bc7f: 5b pop %ebx 10bc80: 5e pop %esi 10bc81: 5f pop %edi 10bc82: c9 leave 10bc83: c3 ret =============================================================================== 0010bbcc <_Objects_Namespace_remove>: void _Objects_Namespace_remove( Objects_Information *information, Objects_Control *the_object ) { 10bbcc: 55 push %ebp 10bbcd: 89 e5 mov %esp,%ebp 10bbcf: 53 push %ebx 10bbd0: 83 ec 04 sub $0x4,%esp 10bbd3: 8b 5d 0c mov 0xc(%ebp),%ebx /* * If this is a string format name, then free the memory. */ if ( information->is_string && the_object->name.name_p ) 10bbd6: 8b 45 08 mov 0x8(%ebp),%eax 10bbd9: 80 78 38 00 cmpb $0x0,0x38(%eax) 10bbdd: 74 13 je 10bbf2 <_Objects_Namespace_remove+0x26><== ALWAYS TAKEN 10bbdf: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 10bbe2: 85 c0 test %eax,%eax <== NOT EXECUTED 10bbe4: 74 0c je 10bbf2 <_Objects_Namespace_remove+0x26><== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10bbe6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10bbe9: 50 push %eax <== NOT EXECUTED 10bbea: e8 19 18 00 00 call 10d408 <_Workspace_Free> <== NOT EXECUTED 10bbef: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * Clear out either format. */ the_object->name.name_p = NULL; the_object->name.name_u32 = 0; 10bbf2: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) } 10bbf9: 8b 5d fc mov -0x4(%ebp),%ebx 10bbfc: c9 leave 10bbfd: c3 ret =============================================================================== 0010d624 <_Objects_Set_name>: bool _Objects_Set_name( Objects_Information *information, Objects_Control *the_object, const char *name ) { 10d624: 55 push %ebp 10d625: 89 e5 mov %esp,%ebp 10d627: 57 push %edi 10d628: 56 push %esi 10d629: 53 push %ebx 10d62a: 83 ec 14 sub $0x14,%esp 10d62d: 8b 5d 08 mov 0x8(%ebp),%ebx 10d630: 8b 7d 10 mov 0x10(%ebp),%edi size_t length; const char *s; s = name; length = strnlen( name, information->name_length ) + 1; 10d633: 0f b7 43 3a movzwl 0x3a(%ebx),%eax 10d637: 50 push %eax 10d638: 57 push %edi 10d639: e8 7e 5c 00 00 call 1132bc 10d63e: 8d 70 01 lea 0x1(%eax),%esi if ( information->is_string ) { 10d641: 83 c4 10 add $0x10,%esp 10d644: 80 7b 38 00 cmpb $0x0,0x38(%ebx) 10d648: 75 5a jne 10d6a4 <_Objects_Set_name+0x80><== NEVER TAKEN strncpy( d, name, length ); d[ length ] = '\0'; the_object->name.name_p = d; } else { the_object->name.name_u32 = _Objects_Build_name( 10d64a: 85 f6 test %esi,%esi 10d64c: 74 3e je 10d68c <_Objects_Set_name+0x68><== NEVER TAKEN 10d64e: 0f be 17 movsbl (%edi),%edx 10d651: c1 e2 18 shl $0x18,%edx 10d654: 83 fe 01 cmp $0x1,%esi 10d657: 0f 84 ae 00 00 00 je 10d70b <_Objects_Set_name+0xe7> 10d65d: 0f be 47 01 movsbl 0x1(%edi),%eax 10d661: c1 e0 10 shl $0x10,%eax 10d664: 09 d0 or %edx,%eax 10d666: 83 fe 02 cmp $0x2,%esi 10d669: 0f 84 89 00 00 00 je 10d6f8 <_Objects_Set_name+0xd4> 10d66f: 0f be 57 02 movsbl 0x2(%edi),%edx 10d673: c1 e2 08 shl $0x8,%edx 10d676: 09 c2 or %eax,%edx 10d678: 83 fe 03 cmp $0x3,%esi 10d67b: 0f 84 83 00 00 00 je 10d704 <_Objects_Set_name+0xe0> 10d681: 0f be 47 03 movsbl 0x3(%edi),%eax 10d685: 09 d0 or %edx,%eax 10d687: eb 08 jmp 10d691 <_Objects_Set_name+0x6d> 10d689: 8d 76 00 lea 0x0(%esi),%esi 10d68c: b8 20 20 20 20 mov $0x20202020,%eax <== NOT EXECUTED 10d691: 8b 55 0c mov 0xc(%ebp),%edx 10d694: 89 42 0c mov %eax,0xc(%edx) 10d697: b0 01 mov $0x1,%al ); } return TRUE; } 10d699: 8d 65 f4 lea -0xc(%ebp),%esp 10d69c: 5b pop %ebx 10d69d: 5e pop %esi 10d69e: 5f pop %edi 10d69f: c9 leave 10d6a0: c3 ret 10d6a1: 8d 76 00 lea 0x0(%esi),%esi length = strnlen( name, information->name_length ) + 1; if ( information->is_string ) { char *d; d = _Workspace_Allocate( length ); 10d6a4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d6a7: 56 push %esi <== NOT EXECUTED 10d6a8: e8 ff 17 00 00 call 10eeac <_Workspace_Allocate> <== NOT EXECUTED 10d6ad: 89 c3 mov %eax,%ebx <== NOT EXECUTED if ( !d ) 10d6af: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d6b2: 85 c0 test %eax,%eax <== NOT EXECUTED 10d6b4: 74 4a je 10d700 <_Objects_Set_name+0xdc><== NOT EXECUTED return FALSE; if ( the_object->name.name_p ) { 10d6b6: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10d6b9: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10d6bc: 85 c0 test %eax,%eax <== NOT EXECUTED 10d6be: 74 16 je 10d6d6 <_Objects_Set_name+0xb2><== NOT EXECUTED _Workspace_Free( (void *)the_object->name.name_p ); 10d6c0: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10d6c3: 50 push %eax <== NOT EXECUTED 10d6c4: e8 cb 17 00 00 call 10ee94 <_Workspace_Free> <== NOT EXECUTED the_object->name.name_p = NULL; 10d6c9: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10d6cc: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) <== NOT EXECUTED 10d6d3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } strncpy( d, name, length ); 10d6d6: 50 push %eax <== NOT EXECUTED 10d6d7: 56 push %esi <== NOT EXECUTED 10d6d8: 57 push %edi <== NOT EXECUTED 10d6d9: 53 push %ebx <== NOT EXECUTED 10d6da: e8 55 5b 00 00 call 113234 <== NOT EXECUTED d[ length ] = '\0'; 10d6df: c6 04 33 00 movb $0x0,(%ebx,%esi,1) <== NOT EXECUTED the_object->name.name_p = d; 10d6e3: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10d6e6: 89 5a 0c mov %ebx,0xc(%edx) <== NOT EXECUTED 10d6e9: b0 01 mov $0x1,%al <== NOT EXECUTED 10d6eb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ); } return TRUE; } 10d6ee: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10d6f1: 5b pop %ebx <== NOT EXECUTED 10d6f2: 5e pop %esi <== NOT EXECUTED 10d6f3: 5f pop %edi <== NOT EXECUTED 10d6f4: c9 leave <== NOT EXECUTED 10d6f5: c3 ret <== NOT EXECUTED 10d6f6: 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( 10d6f8: 0d 20 20 00 00 or $0x2020,%eax 10d6fd: eb 92 jmp 10d691 <_Objects_Set_name+0x6d> 10d6ff: 90 nop if ( information->is_string ) { char *d; d = _Workspace_Allocate( length ); if ( !d ) 10d700: 31 c0 xor %eax,%eax 10d702: eb 95 jmp 10d699 <_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( 10d704: 89 d0 mov %edx,%eax 10d706: 83 c8 20 or $0x20,%eax 10d709: eb 86 jmp 10d691 <_Objects_Set_name+0x6d> 10d70b: 89 d0 mov %edx,%eax 10d70d: 0d 20 20 20 00 or $0x202020,%eax 10d712: e9 7a ff ff ff jmp 10d691 <_Objects_Set_name+0x6d> =============================================================================== 0010bc8c <_Objects_Shrink_information>: */ void _Objects_Shrink_information( Objects_Information *information ) { 10bc8c: 55 push %ebp 10bc8d: 89 e5 mov %esp,%ebp 10bc8f: 57 push %edi 10bc90: 56 push %esi 10bc91: 53 push %ebx 10bc92: 83 ec 0c sub $0xc,%esp * 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 10bc95: 8b 55 08 mov 0x8(%ebp),%edx 10bc98: 8b 42 08 mov 0x8(%edx),%eax 10bc9b: 0f b7 f0 movzwl %ax,%esi /* * 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; 10bc9e: 8b 4a 14 mov 0x14(%edx),%ecx 10bca1: 0f b7 42 10 movzwl 0x10(%edx),%eax 10bca5: 29 f0 sub %esi,%eax 10bca7: 31 d2 xor %edx,%edx 10bca9: f7 f1 div %ecx for ( block = 0; block < block_count; block++ ) { 10bcab: 85 c0 test %eax,%eax 10bcad: 74 24 je 10bcd3 <_Objects_Shrink_information+0x47><== NEVER TAKEN if ( information->inactive_per_block[ block ] == information->allocation_size ) { 10bcaf: 8b 55 08 mov 0x8(%ebp),%edx 10bcb2: 8b 5a 30 mov 0x30(%edx),%ebx 10bcb5: 3b 0b cmp (%ebx),%ecx 10bcb7: 74 22 je 10bcdb <_Objects_Shrink_information+0x4f><== NEVER TAKEN information->object_blocks[ block ] = NULL; information->inactive_per_block[ block ] = 0; information->inactive -= information->allocation_size; return; 10bcb9: 31 d2 xor %edx,%edx 10bcbb: eb 11 jmp 10bcce <_Objects_Shrink_information+0x42> 10bcbd: 8d 76 00 lea 0x0(%esi),%esi } index_base += information->allocation_size; 10bcc0: 01 ce add %ecx,%esi 10bcc2: 8d 3c 95 00 00 00 00 lea 0x0(,%edx,4),%edi 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 ) { 10bcc9: 3b 0c 93 cmp (%ebx,%edx,4),%ecx 10bccc: 74 12 je 10bce0 <_Objects_Shrink_information+0x54> */ index_base = _Objects_Get_index( information->minimum_id ); block_count = ( information->maximum - index_base ) / information->allocation_size; for ( block = 0; block < block_count; block++ ) { 10bcce: 42 inc %edx 10bccf: 39 d0 cmp %edx,%eax 10bcd1: 77 ed ja 10bcc0 <_Objects_Shrink_information+0x34> return; } index_base += information->allocation_size; } } 10bcd3: 8d 65 f4 lea -0xc(%ebp),%esp 10bcd6: 5b pop %ebx 10bcd7: 5e pop %esi 10bcd8: 5f pop %edi 10bcd9: c9 leave 10bcda: c3 ret 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 ) { 10bcdb: 31 ff xor %edi,%edi <== NOT EXECUTED 10bcdd: 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; 10bce0: 8b 5d 08 mov 0x8(%ebp),%ebx 10bce3: 8b 4b 20 mov 0x20(%ebx),%ecx 10bce6: eb 26 jmp 10bd0e <_Objects_Shrink_information+0x82> */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 10bce8: 89 f0 mov %esi,%eax 10bcea: 8b 5d 08 mov 0x8(%ebp),%ebx 10bced: 03 43 14 add 0x14(%ebx),%eax 10bcf0: 39 d0 cmp %edx,%eax 10bcf2: 76 24 jbe 10bd18 <_Objects_Shrink_information+0x8c> * @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, 10bcf4: 8b 19 mov (%ecx),%ebx if ( !_Chain_Is_last( &the_object->Node ) ) the_object = (Objects_Control *) the_object->Node.next; else the_object = NULL; _Chain_Extract( &extract_me->Node ); 10bcf6: 83 ec 0c sub $0xc,%esp 10bcf9: 51 push %ecx 10bcfa: e8 45 33 00 00 call 10f044 <_Chain_Extract> 10bcff: 83 c4 10 add $0x10,%esp } else { the_object = (Objects_Control *) the_object->Node.next; } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 10bd02: 85 db test %ebx,%ebx 10bd04: 74 1a je 10bd20 <_Objects_Shrink_information+0x94><== NEVER TAKEN 10bd06: 8b 03 mov (%ebx),%eax 10bd08: 85 c0 test %eax,%eax 10bd0a: 74 14 je 10bd20 <_Objects_Shrink_information+0x94> 10bd0c: 89 d9 mov %ebx,%ecx * 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 10bd0e: 8b 41 08 mov 0x8(%ecx),%eax 10bd11: 0f b7 d0 movzwl %ax,%edx */ do { index = _Objects_Get_index( the_object->id ); if ((index >= index_base) && 10bd14: 39 f2 cmp %esi,%edx 10bd16: 73 d0 jae 10bce8 <_Objects_Shrink_information+0x5c> the_object = NULL; _Chain_Extract( &extract_me->Node ); } else { the_object = (Objects_Control *) the_object->Node.next; 10bd18: 8b 19 mov (%ecx),%ebx } } while ( the_object && !_Chain_Is_last( &the_object->Node ) ); 10bd1a: 85 db test %ebx,%ebx 10bd1c: 75 e8 jne 10bd06 <_Objects_Shrink_information+0x7a><== ALWAYS TAKEN 10bd1e: 66 90 xchg %ax,%ax /* * Free the memory and reset the structures in the object' information */ _Workspace_Free( information->object_blocks[ block ] ); 10bd20: 83 ec 0c sub $0xc,%esp 10bd23: 8b 55 08 mov 0x8(%ebp),%edx 10bd26: 8b 42 34 mov 0x34(%edx),%eax 10bd29: ff 34 38 pushl (%eax,%edi,1) 10bd2c: e8 d7 16 00 00 call 10d408 <_Workspace_Free> information->object_blocks[ block ] = NULL; 10bd31: 8b 5d 08 mov 0x8(%ebp),%ebx 10bd34: 8b 43 34 mov 0x34(%ebx),%eax 10bd37: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1) information->inactive_per_block[ block ] = 0; 10bd3e: 8b 43 30 mov 0x30(%ebx),%eax 10bd41: c7 04 38 00 00 00 00 movl $0x0,(%eax,%edi,1) information->inactive -= information->allocation_size; 10bd48: 8b 43 14 mov 0x14(%ebx),%eax 10bd4b: 66 29 43 2c sub %ax,0x2c(%ebx) 10bd4f: 83 c4 10 add $0x10,%esp return; } index_base += information->allocation_size; } } 10bd52: 8d 65 f4 lea -0xc(%ebp),%esp 10bd55: 5b pop %ebx 10bd56: 5e pop %esi 10bd57: 5f pop %edi 10bd58: c9 leave 10bd59: c3 ret =============================================================================== 0010dd40 <_Protected_heap_Get_information>: bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ) { 10dd40: 55 push %ebp 10dd41: 89 e5 mov %esp,%ebp 10dd43: 56 push %esi 10dd44: 53 push %ebx 10dd45: 8b 75 08 mov 0x8(%ebp),%esi 10dd48: 8b 5d 0c mov 0xc(%ebp),%ebx Heap_Get_information_status status; if ( !the_heap ) 10dd4b: 85 f6 test %esi,%esi 10dd4d: 74 39 je 10dd88 <_Protected_heap_Get_information+0x48><== NEVER TAKEN return false; if ( !the_info ) 10dd4f: 85 db test %ebx,%ebx 10dd51: 74 35 je 10dd88 <_Protected_heap_Get_information+0x48><== NEVER TAKEN return false; _RTEMS_Lock_allocator(); 10dd53: 83 ec 0c sub $0xc,%esp 10dd56: ff 35 b4 3d 12 00 pushl 0x123db4 10dd5c: e8 63 e8 ff ff call 10c5c4 <_API_Mutex_Lock> status = _Heap_Get_information( the_heap, the_info ); 10dd61: 5a pop %edx 10dd62: 59 pop %ecx 10dd63: 53 push %ebx 10dd64: 56 push %esi 10dd65: e8 e2 37 00 00 call 11154c <_Heap_Get_information> 10dd6a: 89 c3 mov %eax,%ebx _RTEMS_Unlock_allocator(); 10dd6c: 58 pop %eax 10dd6d: ff 35 b4 3d 12 00 pushl 0x123db4 10dd73: e8 94 e8 ff ff call 10c60c <_API_Mutex_Unlock> if ( status == HEAP_GET_INFORMATION_SUCCESSFUL ) 10dd78: 83 c4 10 add $0x10,%esp 10dd7b: 85 db test %ebx,%ebx 10dd7d: 0f 94 c0 sete %al return true; return false; } 10dd80: 8d 65 f8 lea -0x8(%ebp),%esp 10dd83: 5b pop %ebx 10dd84: 5e pop %esi 10dd85: c9 leave 10dd86: c3 ret 10dd87: 90 nop _RTEMS_Lock_allocator(); status = _Heap_Get_information( the_heap, the_info ); _RTEMS_Unlock_allocator(); if ( status == HEAP_GET_INFORMATION_SUCCESSFUL ) 10dd88: 31 c0 xor %eax,%eax return true; return false; } 10dd8a: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10dd8d: 5b pop %ebx <== NOT EXECUTED 10dd8e: 5e pop %esi <== NOT EXECUTED 10dd8f: c9 leave <== NOT EXECUTED 10dd90: c3 ret <== NOT EXECUTED =============================================================================== 0010eee4 <_RTEMS_tasks_Create_extension>: bool _RTEMS_tasks_Create_extension( Thread_Control *executing, Thread_Control *created ) { 10eee4: 55 push %ebp 10eee5: 89 e5 mov %esp,%ebp 10eee7: 53 push %ebx 10eee8: 83 ec 10 sub $0x10,%esp 10eeeb: 8b 5d 0c mov 0xc(%ebp),%ebx /* * 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() ) 10eeee: a1 f4 e6 11 00 mov 0x11e6f4,%eax 10eef3: 8b 40 40 mov 0x40(%eax),%eax 10eef6: 80 78 04 01 cmpb $0x1,0x4(%eax) 10eefa: 19 c0 sbb %eax,%eax 10eefc: 83 e0 c0 and $0xffffffc0,%eax 10eeff: 83 c0 60 add $0x60,%eax to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); 10ef02: 50 push %eax 10ef03: e8 18 e5 ff ff call 10d420 <_Workspace_Allocate> 10ef08: 89 c2 mov %eax,%edx if ( !api ) 10ef0a: 83 c4 10 add $0x10,%esp 10ef0d: 85 c0 test %eax,%eax 10ef0f: 74 67 je 10ef78 <_RTEMS_tasks_Create_extension+0x94><== NEVER TAKEN return false; created->API_Extensions[ THREAD_API_RTEMS ] = api; 10ef11: 89 83 f4 00 00 00 mov %eax,0xf4(%ebx) api->pending_events = EVENT_SETS_NONE_PENDING; 10ef17: c7 00 00 00 00 00 movl $0x0,(%eax) #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 10ef1d: c6 40 08 01 movb $0x1,0x8(%eax) * @a page_size byte units. If @a page_size is 0 or is not multiple of 10ef21: c7 40 0c 00 00 00 00 movl $0x0,0xc(%eax) * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 10ef28: c7 40 10 00 00 00 00 movl $0x0,0x10(%eax) * 10ef2f: c7 40 14 00 00 00 00 movl $0x0,0x14(%eax) * @param[in] the_heap is the heap to operate upon 10ef36: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) * @param[in] starting_address is the starting address of the memory for 10ef3d: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax) _ASR_Initialize( &api->Signal ); created->task_variables = NULL; 10ef44: c7 83 04 01 00 00 00 movl $0x0,0x104(%ebx) 10ef4b: 00 00 00 if ( rtems_configuration_get_notepads_enabled() ) { 10ef4e: a1 f4 e6 11 00 mov 0x11e6f4,%eax 10ef53: 8b 40 40 mov 0x40(%eax),%eax 10ef56: 80 78 04 00 cmpb $0x0,0x4(%eax) 10ef5a: 74 12 je 10ef6e <_RTEMS_tasks_Create_extension+0x8a> 10ef5c: 31 c0 xor %eax,%eax 10ef5e: 66 90 xchg %ax,%ax for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; 10ef60: c7 44 82 20 00 00 00 movl $0x0,0x20(%edx,%eax,4) 10ef67: 00 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++) 10ef68: 40 inc %eax 10ef69: 83 f8 10 cmp $0x10,%eax 10ef6c: 75 f2 jne 10ef60 <_RTEMS_tasks_Create_extension+0x7c> 10ef6e: b0 01 mov $0x1,%al api->Notepads[i] = 0; } return true; } 10ef70: 8b 5d fc mov -0x4(%ebp),%ebx 10ef73: c9 leave 10ef74: c3 ret 10ef75: 8d 76 00 lea 0x0(%esi),%esi if ( !rtems_configuration_get_notepads_enabled() ) to_allocate -= (RTEMS_NUMBER_NOTEPADS * sizeof(uint32_t)); api = _Workspace_Allocate( to_allocate ); if ( !api ) 10ef78: 31 c0 xor %eax,%eax for (i=0; i < RTEMS_NUMBER_NOTEPADS; i++) api->Notepads[i] = 0; } return true; } 10ef7a: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ef7d: c9 leave <== NOT EXECUTED 10ef7e: c3 ret <== NOT EXECUTED =============================================================================== 0010a7b0 <_RTEMS_tasks_Initialize_user_tasks_body>: * * Output parameters: NONE */ void _RTEMS_tasks_Initialize_user_tasks_body( void ) { 10a7b0: 55 push %ebp 10a7b1: 89 e5 mov %esp,%ebp 10a7b3: 57 push %edi 10a7b4: 56 push %esi 10a7b5: 53 push %ebx 10a7b6: 83 ec 1c sub $0x1c,%esp rtems_status_code return_value; rtems_initialization_tasks_table *user_tasks; rtems_api_configuration_table *api_configuration; api_configuration = _Configuration_Table->RTEMS_api_configuration; 10a7b9: a1 f4 e6 11 00 mov 0x11e6f4,%eax 10a7be: 8b 40 40 mov 0x40(%eax),%eax /* * NOTE: This is slightly different from the Ada implementation. */ user_tasks = api_configuration->User_initialization_tasks_table; 10a7c1: 8b 50 2c mov 0x2c(%eax),%edx maximum = api_configuration->number_of_initialization_tasks; 10a7c4: 8b 78 28 mov 0x28(%eax),%edi if ( !user_tasks || maximum == 0 ) 10a7c7: 85 d2 test %edx,%edx 10a7c9: 74 48 je 10a813 <_RTEMS_tasks_Initialize_user_tasks_body+0x63><== NEVER TAKEN 10a7cb: 85 ff test %edi,%edi 10a7cd: 74 44 je 10a813 <_RTEMS_tasks_Initialize_user_tasks_body+0x63><== NEVER TAKEN 10a7cf: 89 d3 mov %edx,%ebx 10a7d1: 31 f6 xor %esi,%esi 10a7d3: 90 nop return; for ( index=0 ; index < maximum ; index++ ) { return_value = rtems_task_create( 10a7d4: 83 ec 08 sub $0x8,%esp 10a7d7: 8d 45 f0 lea -0x10(%ebp),%eax 10a7da: 50 push %eax 10a7db: ff 73 0c pushl 0xc(%ebx) 10a7de: ff 73 14 pushl 0x14(%ebx) 10a7e1: ff 73 04 pushl 0x4(%ebx) 10a7e4: ff 73 08 pushl 0x8(%ebx) 10a7e7: ff 33 pushl (%ebx) 10a7e9: e8 9a fd ff ff call 10a588 user_tasks[ index ].mode_set, user_tasks[ index ].attribute_set, &id ); if ( !rtems_is_status_successful( return_value ) ) 10a7ee: 83 c4 20 add $0x20,%esp 10a7f1: 85 c0 test %eax,%eax 10a7f3: 75 27 jne 10a81c <_RTEMS_tasks_Initialize_user_tasks_body+0x6c> _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); return_value = rtems_task_start( 10a7f5: 51 push %ecx 10a7f6: ff 73 18 pushl 0x18(%ebx) 10a7f9: ff 73 10 pushl 0x10(%ebx) 10a7fc: ff 75 f0 pushl -0x10(%ebp) 10a7ff: e8 24 00 00 00 call 10a828 id, user_tasks[ index ].entry_point, user_tasks[ index ].argument ); if ( !rtems_is_status_successful( return_value ) ) 10a804: 83 c4 10 add $0x10,%esp 10a807: 85 c0 test %eax,%eax 10a809: 75 11 jne 10a81c <_RTEMS_tasks_Initialize_user_tasks_body+0x6c> maximum = api_configuration->number_of_initialization_tasks; if ( !user_tasks || maximum == 0 ) return; for ( index=0 ; index < maximum ; index++ ) { 10a80b: 46 inc %esi 10a80c: 83 c3 1c add $0x1c,%ebx 10a80f: 39 f7 cmp %esi,%edi 10a811: 77 c1 ja 10a7d4 <_RTEMS_tasks_Initialize_user_tasks_body+0x24><== NEVER TAKEN ); if ( !rtems_is_status_successful( return_value ) ) _Internal_error_Occurred( INTERNAL_ERROR_RTEMS_API, TRUE, return_value ); } } 10a813: 8d 65 f4 lea -0xc(%ebp),%esp 10a816: 5b pop %ebx 10a817: 5e pop %esi 10a818: 5f pop %edi 10a819: c9 leave 10a81a: c3 ret 10a81b: 90 nop 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 ); 10a81c: 52 push %edx 10a81d: 50 push %eax 10a81e: 6a 01 push $0x1 10a820: 6a 01 push $0x1 10a822: e8 f9 0c 00 00 call 10b520 <_Internal_error_Occurred> =============================================================================== 0010ee2c <_RTEMS_tasks_Post_switch_extension>: */ void _RTEMS_tasks_Post_switch_extension( Thread_Control *executing ) { 10ee2c: 55 push %ebp 10ee2d: 89 e5 mov %esp,%ebp 10ee2f: 57 push %edi 10ee30: 56 push %esi 10ee31: 53 push %ebx 10ee32: 83 ec 1c sub $0x1c,%esp RTEMS_API_Control *api; ASR_Information *asr; rtems_signal_set signal_set; Modes_Control prev_mode; api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10ee35: 8b 45 08 mov 0x8(%ebp),%eax 10ee38: 8b b0 f4 00 00 00 mov 0xf4(%eax),%esi if ( !api ) 10ee3e: 85 f6 test %esi,%esi 10ee40: 74 45 je 10ee87 <_RTEMS_tasks_Post_switch_extension+0x5b><== NEVER TAKEN * Signal Processing */ asr = &api->Signal; _ISR_Disable( level ); 10ee42: 9c pushf 10ee43: fa cli 10ee44: 58 pop %eax signal_set = asr->signals_posted; 10ee45: 8b 7e 14 mov 0x14(%esi),%edi asr->signals_posted = 0; 10ee48: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) _ISR_Enable( level ); 10ee4f: 50 push %eax 10ee50: 9d popf if ( !signal_set ) /* similar to _ASR_Are_signals_pending( asr ) */ 10ee51: 85 ff test %edi,%edi 10ee53: 74 32 je 10ee87 <_RTEMS_tasks_Post_switch_extension+0x5b><== NEVER TAKEN return; asr->nest_level += 1; 10ee55: ff 46 1c incl 0x1c(%esi) rtems_task_mode( asr->mode_set, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10ee58: 50 push %eax 10ee59: 8d 5d f0 lea -0x10(%ebp),%ebx 10ee5c: 53 push %ebx 10ee5d: 68 ff ff 00 00 push $0xffff 10ee62: ff 76 10 pushl 0x10(%esi) 10ee65: e8 e6 0e 00 00 call 10fd50 (*asr->handler)( signal_set ); 10ee6a: 89 3c 24 mov %edi,(%esp) 10ee6d: ff 56 0c call *0xc(%esi) asr->nest_level -= 1; 10ee70: ff 4e 1c decl 0x1c(%esi) rtems_task_mode( prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode ); 10ee73: 83 c4 0c add $0xc,%esp 10ee76: 53 push %ebx 10ee77: 68 ff ff 00 00 push $0xffff 10ee7c: ff 75 f0 pushl -0x10(%ebp) 10ee7f: e8 cc 0e 00 00 call 10fd50 10ee84: 83 c4 10 add $0x10,%esp } 10ee87: 8d 65 f4 lea -0xc(%ebp),%esp 10ee8a: 5b pop %ebx 10ee8b: 5e pop %esi 10ee8c: 5f pop %edi 10ee8d: c9 leave 10ee8e: c3 ret =============================================================================== 0010ed90 <_RTEMS_tasks_Switch_extension>: void _RTEMS_tasks_Switch_extension( Thread_Control *executing, Thread_Control *heir ) { 10ed90: 55 push %ebp 10ed91: 89 e5 mov %esp,%ebp /* * Per Task Variables */ tvp = executing->task_variables; 10ed93: 8b 45 08 mov 0x8(%ebp),%eax 10ed96: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx while (tvp) { 10ed9c: 85 c9 test %ecx,%ecx 10ed9e: 74 13 je 10edb3 <_RTEMS_tasks_Switch_extension+0x23> tvp->tval = *tvp->ptr; 10eda0: 8b 41 04 mov 0x4(%ecx),%eax 10eda3: 8b 10 mov (%eax),%edx 10eda5: 89 51 0c mov %edx,0xc(%ecx) *tvp->ptr = tvp->gval; 10eda8: 8b 51 08 mov 0x8(%ecx),%edx 10edab: 89 10 mov %edx,(%eax) tvp = (rtems_task_variable_t *)tvp->next; 10edad: 8b 09 mov (%ecx),%ecx /* * Per Task Variables */ tvp = executing->task_variables; while (tvp) { 10edaf: 85 c9 test %ecx,%ecx 10edb1: 75 ed jne 10eda0 <_RTEMS_tasks_Switch_extension+0x10><== NEVER TAKEN tvp->tval = *tvp->ptr; *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; 10edb3: 8b 45 0c mov 0xc(%ebp),%eax 10edb6: 8b 88 04 01 00 00 mov 0x104(%eax),%ecx while (tvp) { 10edbc: 85 c9 test %ecx,%ecx 10edbe: 74 13 je 10edd3 <_RTEMS_tasks_Switch_extension+0x43> tvp->gval = *tvp->ptr; 10edc0: 8b 41 04 mov 0x4(%ecx),%eax 10edc3: 8b 10 mov (%eax),%edx 10edc5: 89 51 08 mov %edx,0x8(%ecx) *tvp->ptr = tvp->tval; 10edc8: 8b 51 0c mov 0xc(%ecx),%edx 10edcb: 89 10 mov %edx,(%eax) tvp = (rtems_task_variable_t *)tvp->next; 10edcd: 8b 09 mov (%ecx),%ecx *tvp->ptr = tvp->gval; tvp = (rtems_task_variable_t *)tvp->next; } tvp = heir->task_variables; while (tvp) { 10edcf: 85 c9 test %ecx,%ecx 10edd1: 75 ed jne 10edc0 <_RTEMS_tasks_Switch_extension+0x30><== NEVER TAKEN tvp->gval = *tvp->ptr; *tvp->ptr = tvp->tval; tvp = (rtems_task_variable_t *)tvp->next; } } 10edd3: c9 leave 10edd4: c3 ret =============================================================================== 0010b0f0 <_Rate_monotonic_Initiate_statistics>: #endif void _Rate_monotonic_Initiate_statistics( Rate_monotonic_Control *the_period ) { 10b0f0: 55 push %ebp 10b0f1: 89 e5 mov %esp,%ebp 10b0f3: 57 push %edi 10b0f4: 56 push %esi 10b0f5: 53 push %ebx 10b0f6: 83 ec 28 sub $0x28,%esp 10b0f9: 8b 75 08 mov 0x8(%ebp),%esi Thread_Control *owning_thread = the_period->owner; 10b0fc: 8b 5e 50 mov 0x50(%esi),%ebx #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) || \ defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) struct timespec uptime; _TOD_Get_uptime( &uptime ); 10b0ff: 8d 7d ec lea -0x14(%ebp),%edi 10b102: 57 push %edi 10b103: e8 6c 19 00 00 call 10ca74 <_TOD_Get_uptime> /* * 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; 10b108: 8b 45 ec mov -0x14(%ebp),%eax 10b10b: 8b 55 f0 mov -0x10(%ebp),%edx 10b10e: 89 46 44 mov %eax,0x44(%esi) 10b111: 89 56 48 mov %edx,0x48(%esi) #else the_period->time_at_period = _Watchdog_Ticks_since_boot; #endif the_period->owner_executed_at_period = owning_thread->cpu_time_used; 10b114: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx 10b11a: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 10b120: 89 46 40 mov %eax,0x40(%esi) 10b123: 89 56 3c mov %edx,0x3c(%esi) * 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) { 10b126: 83 c4 10 add $0x10,%esp 10b129: 3b 1d 3c 28 12 00 cmp 0x12283c,%ebx 10b12f: 74 0b je 10b13c <_Rate_monotonic_Initiate_statistics+0x4c> ); _Timespec_Add_to( &the_period->owner_executed_at_period, &ran ); } #endif } 10b131: 8d 65 f4 lea -0xc(%ebp),%esp 10b134: 5b pop %ebx 10b135: 5e pop %esi 10b136: 5f pop %edi 10b137: c9 leave 10b138: c3 ret 10b139: 8d 76 00 lea 0x0(%esi),%esi /* * Adjust the CPU time used to account for the time since last * context switch. */ _Timespec_Subtract( 10b13c: 51 push %ecx 10b13d: 8d 5d e4 lea -0x1c(%ebp),%ebx 10b140: 53 push %ebx 10b141: 57 push %edi 10b142: 68 44 28 12 00 push $0x122844 10b147: e8 04 39 00 00 call 10ea50 <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &ran ); _Timespec_Add_to( &the_period->owner_executed_at_period, &ran ); 10b14c: 58 pop %eax 10b14d: 5a pop %edx 10b14e: 53 push %ebx 10b14f: 8d 46 3c lea 0x3c(%esi),%eax 10b152: 50 push %eax 10b153: e8 04 38 00 00 call 10e95c <_Timespec_Add_to> 10b158: 83 c4 10 add $0x10,%esp 10b15b: eb d4 jmp 10b131 <_Rate_monotonic_Initiate_statistics+0x41> =============================================================================== 0010b724 <_Rate_monotonic_Timeout>: void _Rate_monotonic_Timeout( Objects_Id id, void *ignored ) { 10b724: 55 push %ebp 10b725: 89 e5 mov %esp,%ebp 10b727: 53 push %ebx 10b728: 83 ec 18 sub $0x18,%esp 10b72b: 8d 45 f8 lea -0x8(%ebp),%eax 10b72e: 50 push %eax 10b72f: ff 75 08 pushl 0x8(%ebp) 10b732: 68 80 26 12 00 push $0x122680 10b737: e8 a4 1c 00 00 call 10d3e0 <_Objects_Get> 10b73c: 89 c3 mov %eax,%ebx /* * 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 ) { 10b73e: 83 c4 10 add $0x10,%esp 10b741: 8b 45 f8 mov -0x8(%ebp),%eax 10b744: 85 c0 test %eax,%eax 10b746: 75 21 jne 10b769 <_Rate_monotonic_Timeout+0x45><== NEVER TAKEN case OBJECTS_LOCAL: the_thread = the_period->owner; 10b748: 8b 53 50 mov 0x50(%ebx),%edx if ( _States_Is_waiting_for_period( the_thread->current_state ) && 10b74b: f6 42 11 40 testb $0x40,0x11(%edx) 10b74f: 75 1f jne 10b770 <_Rate_monotonic_Timeout+0x4c> _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 ) { 10b751: 83 7b 38 01 cmpl $0x1,0x38(%ebx) 10b755: 74 35 je 10b78c <_Rate_monotonic_Timeout+0x68><== NEVER TAKEN _Rate_monotonic_Initiate_statistics( the_period ); _Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length ); } else the_period->state = RATE_MONOTONIC_EXPIRED; 10b757: c7 43 38 04 00 00 00 movl $0x4,0x38(%ebx) 10b75e: a1 78 27 12 00 mov 0x122778,%eax 10b763: 48 dec %eax 10b764: a3 78 27 12 00 mov %eax,0x122778 case OBJECTS_REMOTE: /* impossible */ #endif case OBJECTS_ERROR: break; } } 10b769: 8b 5d fc mov -0x4(%ebp),%ebx 10b76c: c9 leave 10b76d: c3 ret 10b76e: 66 90 xchg %ax,%ax 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 ) && 10b770: 8b 42 20 mov 0x20(%edx),%eax 10b773: 3b 43 08 cmp 0x8(%ebx),%eax 10b776: 75 d9 jne 10b751 <_Rate_monotonic_Timeout+0x2d><== NEVER TAKEN void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10b778: 83 ec 08 sub $0x8,%esp 10b77b: 68 f8 ff 03 10 push $0x1003fff8 10b780: 52 push %edx 10b781: e8 f6 20 00 00 call 10d87c <_Thread_Clear_state> the_thread->Wait.id == the_period->Object.id ) { _Thread_Unblock( the_thread ); _Rate_monotonic_Initiate_statistics( the_period ); 10b786: 59 pop %ecx 10b787: eb 0d jmp 10b796 <_Rate_monotonic_Timeout+0x72> 10b789: 8d 76 00 lea 0x0(%esi),%esi _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; 10b78c: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) <== NOT EXECUTED _Rate_monotonic_Initiate_statistics( the_period ); 10b793: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10b796: 53 push %ebx 10b797: e8 54 f9 ff ff call 10b0f0 <_Rate_monotonic_Initiate_statistics> * @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, 10b79c: 8b 43 4c mov 0x4c(%ebx),%eax 10b79f: 89 43 1c mov %eax,0x1c(%ebx) void *starting_address, size_t *size 10b7a2: 58 pop %eax 10b7a3: 5a pop %edx 10b7a4: 8d 43 10 lea 0x10(%ebx),%eax 10b7a7: 50 push %eax 10b7a8: 68 5c 28 12 00 push $0x12285c 10b7ad: e8 46 35 00 00 call 10ecf8 <_Watchdog_Insert> 10b7b2: 83 c4 10 add $0x10,%esp 10b7b5: eb a7 jmp 10b75e <_Rate_monotonic_Timeout+0x3a> =============================================================================== 0010b2cc <_TOD_Tickle_ticks>: * * Output parameters: NONE */ void _TOD_Tickle_ticks( void ) { 10b2cc: 55 push %ebp 10b2cd: 89 e5 mov %esp,%ebp 10b2cf: 53 push %ebx 10b2d0: 83 ec 1c sub $0x1c,%esp struct timespec tick; uint32_t seconds; /* Convert the tick quantum to a timespec */ tick.tv_nsec = _TOD_Microseconds_per_tick * 1000; 10b2d3: a1 20 e8 11 00 mov 0x11e820,%eax 10b2d8: 8d 04 80 lea (%eax,%eax,4),%eax 10b2db: 8d 04 80 lea (%eax,%eax,4),%eax 10b2de: 8d 04 80 lea (%eax,%eax,4),%eax 10b2e1: c1 e0 03 shl $0x3,%eax 10b2e4: 89 45 f8 mov %eax,-0x8(%ebp) tick.tv_sec = 0; 10b2e7: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp) /* Update the counter of ticks since boot */ _Watchdog_Ticks_since_boot += 1; 10b2ee: a1 c4 e7 11 00 mov 0x11e7c4,%eax 10b2f3: 40 inc %eax 10b2f4: a3 c4 e7 11 00 mov %eax,0x11e7c4 /* Update the timespec format uptime */ (void) _Timespec_Add_to( &_TOD_Uptime, &tick ); 10b2f9: 8d 5d f4 lea -0xc(%ebp),%ebx 10b2fc: 53 push %ebx 10b2fd: 68 d8 e6 11 00 push $0x11e6d8 10b302: e8 15 1c 00 00 call 10cf1c <_Timespec_Add_to> /* we do not care how much the uptime changed */ /* Update the timespec format TOD */ seconds = _Timespec_Add_to( &_TOD_Now, &tick ); 10b307: 58 pop %eax 10b308: 5a pop %edx 10b309: 53 push %ebx 10b30a: 68 ec e6 11 00 push $0x11e6ec 10b30f: e8 08 1c 00 00 call 10cf1c <_Timespec_Add_to> 10b314: 89 c3 mov %eax,%ebx while ( seconds ) { 10b316: 83 c4 10 add $0x10,%esp 10b319: 85 c0 test %eax,%eax 10b31b: 74 16 je 10b333 <_TOD_Tickle_ticks+0x67> 10b31d: 8d 76 00 lea 0x0(%esi),%esi */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, size_t size, uint32_t alignment ); 10b320: 83 ec 0c sub $0xc,%esp 10b323: 68 30 e7 11 00 push $0x11e730 10b328: e8 6b 20 00 00 call 10d398 <_Watchdog_Tickle> 10b32d: 83 c4 10 add $0x10,%esp 10b330: 4b dec %ebx 10b331: 75 ed jne 10b320 <_TOD_Tickle_ticks+0x54><== NEVER TAKEN _Watchdog_Tickle_seconds(); seconds--; } } 10b333: 8b 5d fc mov -0x4(%ebp),%ebx 10b336: c9 leave 10b337: c3 ret =============================================================================== 0010ac64 <_TOD_To_seconds>: */ uint32_t _TOD_To_seconds( rtems_time_of_day *the_tod ) { 10ac64: 55 push %ebp 10ac65: 89 e5 mov %esp,%ebp 10ac67: 57 push %edi 10ac68: 56 push %esi 10ac69: 53 push %ebx 10ac6a: 8b 5d 08 mov 0x8(%ebp),%ebx uint32_t time; uint32_t year_mod_4; time = the_tod->day - 1; 10ac6d: 8b 43 08 mov 0x8(%ebx),%eax 10ac70: 8d 48 ff lea -0x1(%eax),%ecx year_mod_4 = the_tod->year & 3; 10ac73: 8b 13 mov (%ebx),%edx if ( year_mod_4 == 0 ) 10ac75: 89 d6 mov %edx,%esi 10ac77: 83 e6 03 and $0x3,%esi 10ac7a: 74 68 je 10ace4 <_TOD_To_seconds+0x80> time += _TOD_Days_to_date[ 1 ][ the_tod->month ]; else time += _TOD_Days_to_date[ 0 ][ the_tod->month ]; 10ac7c: 8b 43 04 mov 0x4(%ebx),%eax 10ac7f: 0f b7 84 00 00 b8 11 movzwl 0x11b800(%eax,%eax,1),%eax 10ac86: 00 10ac87: 8d 3c 08 lea (%eax,%ecx,1),%edi time += ( (the_tod->year - TOD_BASE_YEAR) / 4 ) * 10ac8a: 0f b7 8c 36 34 b8 11 movzwl 0x11b834(%esi,%esi,1),%ecx 10ac91: 00 10ac92: 81 ea c4 07 00 00 sub $0x7c4,%edx 10ac98: c1 ea 02 shr $0x2,%edx 10ac9b: 8d 04 d2 lea (%edx,%edx,8),%eax 10ac9e: 8d 04 c2 lea (%edx,%eax,8),%eax 10aca1: 8d 04 80 lea (%eax,%eax,4),%eax 10aca4: 8d 04 82 lea (%edx,%eax,4),%eax 10aca7: 01 c1 add %eax,%ecx ( (TOD_DAYS_PER_YEAR * 4) + 1); time += _TOD_Days_since_last_leap_year[ year_mod_4 ]; 10aca9: 01 f9 add %edi,%ecx time *= TOD_SECONDS_PER_DAY; 10acab: 8d 14 89 lea (%ecx,%ecx,4),%edx 10acae: 8d 14 91 lea (%ecx,%edx,4),%edx 10acb1: 8d 14 d1 lea (%ecx,%edx,8),%edx 10acb4: c1 e2 02 shl $0x2,%edx 10acb7: 29 ca sub %ecx,%edx 10acb9: c1 e2 07 shl $0x7,%edx time += ((the_tod->hour * TOD_MINUTES_PER_HOUR) + the_tod->minute) 10acbc: 8b 4b 14 mov 0x14(%ebx),%ecx * TOD_SECONDS_PER_MINUTE; time += the_tod->second; 10acbf: 8b 43 0c mov 0xc(%ebx),%eax 10acc2: 8d 04 40 lea (%eax,%eax,2),%eax 10acc5: 8d 04 80 lea (%eax,%eax,4),%eax 10acc8: c1 e0 02 shl $0x2,%eax 10accb: 03 43 10 add 0x10(%ebx),%eax 10acce: 8d 04 40 lea (%eax,%eax,2),%eax 10acd1: 8d 04 80 lea (%eax,%eax,4),%eax 10acd4: 8d 84 81 00 e5 da 21 lea 0x21dae500(%ecx,%eax,4),%eax 10acdb: 01 d0 add %edx,%eax time += TOD_SECONDS_1970_THROUGH_1988; return( time ); } 10acdd: 5b pop %ebx 10acde: 5e pop %esi 10acdf: 5f pop %edi 10ace0: c9 leave 10ace1: c3 ret 10ace2: 66 90 xchg %ax,%ax 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 ]; 10ace4: 8b 43 04 mov 0x4(%ebx),%eax 10ace7: 0f b7 84 00 1a b8 11 movzwl 0x11b81a(%eax,%eax,1),%eax 10acee: 00 10acef: 8d 3c 08 lea (%eax,%ecx,1),%edi 10acf2: eb 96 jmp 10ac8a <_TOD_To_seconds+0x26> =============================================================================== 0010acf4 <_TOD_Validate>: */ bool _TOD_Validate( rtems_time_of_day *the_tod ) { 10acf4: 55 push %ebp 10acf5: 89 e5 mov %esp,%ebp 10acf7: 53 push %ebx 10acf8: 83 ec 04 sub $0x4,%esp 10acfb: 8b 5d 08 mov 0x8(%ebp),%ebx uint32_t days_in_month; if ((!the_tod) || 10acfe: 85 db test %ebx,%ebx 10ad00: 74 56 je 10ad58 <_TOD_Validate+0x64> <== NEVER TAKEN 10ad02: b8 40 42 0f 00 mov $0xf4240,%eax 10ad07: 31 d2 xor %edx,%edx 10ad09: f7 35 40 a8 12 00 divl 0x12a840 10ad0f: 39 43 18 cmp %eax,0x18(%ebx) 10ad12: 73 44 jae 10ad58 <_TOD_Validate+0x64> 10ad14: 83 7b 14 3b cmpl $0x3b,0x14(%ebx) 10ad18: 77 3e ja 10ad58 <_TOD_Validate+0x64> 10ad1a: 83 7b 10 3b cmpl $0x3b,0x10(%ebx) 10ad1e: 77 38 ja 10ad58 <_TOD_Validate+0x64> 10ad20: 83 7b 0c 17 cmpl $0x17,0xc(%ebx) 10ad24: 77 32 ja 10ad58 <_TOD_Validate+0x64> 10ad26: 8b 43 04 mov 0x4(%ebx),%eax 10ad29: 85 c0 test %eax,%eax 10ad2b: 74 2b je 10ad58 <_TOD_Validate+0x64> <== NEVER TAKEN 10ad2d: 83 f8 0c cmp $0xc,%eax 10ad30: 77 26 ja 10ad58 <_TOD_Validate+0x64> 10ad32: 8b 0b mov (%ebx),%ecx 10ad34: 81 f9 c3 07 00 00 cmp $0x7c3,%ecx 10ad3a: 76 1c jbe 10ad58 <_TOD_Validate+0x64> 10ad3c: 8b 53 08 mov 0x8(%ebx),%edx 10ad3f: 85 d2 test %edx,%edx 10ad41: 74 15 je 10ad58 <_TOD_Validate+0x64> <== NEVER TAKEN (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 ) 10ad43: 83 e1 03 and $0x3,%ecx 10ad46: 75 16 jne 10ad5e <_TOD_Validate+0x6a> days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ]; 10ad48: 8b 04 85 74 b8 11 00 mov 0x11b874(,%eax,4),%eax else days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ]; 10ad4f: 39 d0 cmp %edx,%eax 10ad51: 0f 93 c0 setae %al 10ad54: eb 04 jmp 10ad5a <_TOD_Validate+0x66> 10ad56: 66 90 xchg %ax,%ax 10ad58: 31 c0 xor %eax,%eax if ( the_tod->day > days_in_month ) return false; return true; } 10ad5a: 5a pop %edx 10ad5b: 5b pop %ebx 10ad5c: c9 leave 10ad5d: c3 ret 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 ]; 10ad5e: 8b 04 85 40 b8 11 00 mov 0x11b840(,%eax,4),%eax 10ad65: eb e8 jmp 10ad4f <_TOD_Validate+0x5b> =============================================================================== 0010be10 <_Thread_Change_priority>: void _Thread_Change_priority( Thread_Control *the_thread, Priority_Control new_priority, bool prepend_it ) { 10be10: 55 push %ebp 10be11: 89 e5 mov %esp,%ebp 10be13: 57 push %edi 10be14: 56 push %esi 10be15: 53 push %ebx 10be16: 83 ec 18 sub $0x18,%esp 10be19: 8b 5d 08 mov 0x8(%ebp),%ebx 10be1c: 8b 75 0c mov 0xc(%ebp),%esi 10be1f: 8a 45 10 mov 0x10(%ebp),%al 10be22: 88 45 f3 mov %al,-0xd(%ebp) */ /* * Save original state */ original_state = the_thread->current_state; 10be25: 8b 7b 10 mov 0x10(%ebx),%edi /* * 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 ); 10be28: 53 push %ebx 10be29: e8 4a 0e 00 00 call 10cc78 <_Thread_Set_transient> /* * Do not bother recomputing all the priority related information if * we are not REALLY changing priority. */ if ( the_thread->current_priority != new_priority ) 10be2e: 83 c4 10 add $0x10,%esp 10be31: 39 73 14 cmp %esi,0x14(%ebx) 10be34: 74 0d je 10be43 <_Thread_Change_priority+0x33> _Thread_Set_priority( the_thread, new_priority ); 10be36: 83 ec 08 sub $0x8,%esp 10be39: 56 push %esi 10be3a: 53 push %ebx 10be3b: e8 f4 0c 00 00 call 10cb34 <_Thread_Set_priority> 10be40: 83 c4 10 add $0x10,%esp _ISR_Disable( level ); 10be43: 9c pushf 10be44: fa cli 10be45: 5e pop %esi /* * 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; 10be46: 8b 53 10 mov 0x10(%ebx),%edx if ( state != STATES_TRANSIENT ) { 10be49: 83 fa 04 cmp $0x4,%edx 10be4c: 74 3a je 10be88 <_Thread_Change_priority+0x78> /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) 10be4e: 83 e7 04 and $0x4,%edi 10be51: 75 08 jne 10be5b <_Thread_Change_priority+0x4b><== NEVER TAKEN the_thread->current_state = _States_Clear( STATES_TRANSIENT, state ); 10be53: 89 d0 mov %edx,%eax 10be55: 83 e0 fb and $0xfffffffb,%eax 10be58: 89 43 10 mov %eax,0x10(%ebx) _ISR_Enable( level ); 10be5b: 56 push %esi 10be5c: 9d popf if ( _States_Is_waiting_on_thread_queue( state ) ) { 10be5d: 81 e2 e0 be 03 00 and $0x3bee0,%edx 10be63: 75 0b jne 10be70 <_Thread_Change_priority+0x60> if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10be65: 8d 65 f4 lea -0xc(%ebp),%esp 10be68: 5b pop %ebx 10be69: 5e pop %esi 10be6a: 5f pop %edi 10be6b: c9 leave 10be6c: c3 ret 10be6d: 8d 76 00 lea 0x0(%esi),%esi /* 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 ); 10be70: 89 5d 0c mov %ebx,0xc(%ebp) 10be73: 8b 43 44 mov 0x44(%ebx),%eax 10be76: 89 45 08 mov %eax,0x8(%ebp) if ( !_Thread_Is_executing_also_the_heir() && _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10be79: 8d 65 f4 lea -0xc(%ebp),%esp 10be7c: 5b pop %ebx 10be7d: 5e pop %esi 10be7e: 5f pop %edi 10be7f: c9 leave /* 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 ); 10be80: e9 1b 0c 00 00 jmp 10caa0 <_Thread_queue_Requeue> 10be85: 8d 76 00 lea 0x0(%esi),%esi } return; } /* Only clear the transient state if it wasn't set already */ if ( ! _States_Is_transient( original_state ) ) { 10be88: 83 e7 04 and $0x4,%edi 10be8b: 75 41 jne 10bece <_Thread_Change_priority+0xbe><== NEVER TAKEN * 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 ); 10be8d: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) * 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 10be94: 8b 93 90 00 00 00 mov 0x90(%ebx),%edx 10be9a: 66 8b 83 96 00 00 00 mov 0x96(%ebx),%ax 10bea1: 66 09 02 or %ax,(%edx) * @return TRUE if successfully able to determine the size, FALSE otherwise 10bea4: 66 a1 10 e7 11 00 mov 0x11e710,%ax 10beaa: 0b 83 94 00 00 00 or 0x94(%ebx),%eax 10beb0: 66 a3 10 e7 11 00 mov %ax,0x11e710 _Priority_Add_to_bit_map( &the_thread->Priority_map ); if ( prepend_it ) 10beb6: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) 10beba: 74 70 je 10bf2c <_Thread_Change_priority+0x11c> 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 10bebc: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax 10bec2: 89 43 04 mov %eax,0x4(%ebx) 10bec5: 8b 10 mov (%eax),%edx 10bec7: 89 18 mov %ebx,(%eax) 10bec9: 89 13 mov %edx,(%ebx) 10becb: 89 5a 04 mov %ebx,0x4(%edx) _Chain_Prepend_unprotected( the_thread->ready, &the_thread->Object.Node ); else _Chain_Append_unprotected( the_thread->ready, &the_thread->Object.Node ); } _ISR_Flash( level ); 10bece: 56 push %esi 10becf: 9d popf 10bed0: fa cli void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10bed1: 66 8b 0d 10 e7 11 00 mov 0x11e710,%cx 10bed8: 31 d2 xor %edx,%edx 10beda: 89 d0 mov %edx,%eax 10bedc: 66 0f bc c1 bsf %cx,%ax * at @a starting_address to @a the_heap. Any coalescing which is 10bee0: 0f b7 c0 movzwl %ax,%eax 10bee3: 66 8b 8c 00 a0 e7 11 mov 0x11e7a0(%eax,%eax,1),%cx 10beea: 00 10beeb: 66 0f bc d1 bsf %cx,%dx /** * 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. 10beef: c1 e0 04 shl $0x4,%eax 10bef2: 0f b7 d2 movzwl %dx,%edx 10bef5: 01 d0 add %edx,%eax 10bef7: 8d 04 40 lea (%eax,%eax,2),%eax 10befa: 8b 15 20 e6 11 00 mov 0x11e620,%edx 10bf00: 8b 04 82 mov (%edx,%eax,4),%eax 10bf03: a3 e8 e6 11 00 mov %eax,0x11e6e8 void *starting_address, size_t size ); /** * This function attempts to allocate a block of @a size bytes from 10bf08: 8b 15 1c e7 11 00 mov 0x11e71c,%edx * 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() && 10bf0e: 39 d0 cmp %edx,%eax 10bf10: 74 0d je 10bf1f <_Thread_Change_priority+0x10f> 10bf12: 80 7a 76 00 cmpb $0x0,0x76(%edx) 10bf16: 74 07 je 10bf1f <_Thread_Change_priority+0x10f><== NEVER TAKEN _Thread_Executing->is_preemptible ) _Context_Switch_necessary = TRUE; 10bf18: c6 05 2c e7 11 00 01 movb $0x1,0x11e72c _ISR_Enable( level ); 10bf1f: 56 push %esi 10bf20: 9d popf } 10bf21: 8d 65 f4 lea -0xc(%ebp),%esp 10bf24: 5b pop %ebx 10bf25: 5e pop %esi 10bf26: 5f pop %edi 10bf27: c9 leave 10bf28: c3 ret 10bf29: 8d 76 00 lea 0x0(%esi),%esi _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 ); 10bf2c: 8b 83 8c 00 00 00 mov 0x8c(%ebx),%eax 10bf32: 8d 50 04 lea 0x4(%eax),%edx 10bf35: 89 13 mov %edx,(%ebx) 10bf37: 8b 50 08 mov 0x8(%eax),%edx 10bf3a: 89 58 08 mov %ebx,0x8(%eax) 10bf3d: 89 1a mov %ebx,(%edx) 10bf3f: 89 53 04 mov %edx,0x4(%ebx) 10bf42: eb 8a jmp 10bece <_Thread_Change_priority+0xbe> =============================================================================== 0010bf44 <_Thread_Clear_state>: void _Thread_Clear_state( Thread_Control *the_thread, States_Control state ) { 10bf44: 55 push %ebp 10bf45: 89 e5 mov %esp,%ebp 10bf47: 53 push %ebx 10bf48: 8b 4d 08 mov 0x8(%ebp),%ecx ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10bf4b: 9c pushf 10bf4c: fa cli 10bf4d: 5b pop %ebx current_state = the_thread->current_state; 10bf4e: 8b 51 10 mov 0x10(%ecx),%edx if ( current_state & state ) { 10bf51: 85 55 0c test %edx,0xc(%ebp) 10bf54: 74 72 je 10bfc8 <_Thread_Clear_state+0x84> * @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( 10bf56: 8b 45 0c mov 0xc(%ebp),%eax 10bf59: f7 d0 not %eax 10bf5b: 21 d0 and %edx,%eax current_state = 10bf5d: 89 41 10 mov %eax,0x10(%ecx) the_thread->current_state = _States_Clear( state, current_state ); if ( _States_Is_ready( current_state ) ) { 10bf60: 85 c0 test %eax,%eax 10bf62: 75 64 jne 10bfc8 <_Thread_Clear_state+0x84> * 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 10bf64: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx 10bf6a: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax 10bf71: 66 09 02 or %ax,(%edx) * @return TRUE if successfully able to determine the size, FALSE otherwise 10bf74: 66 a1 10 e7 11 00 mov 0x11e710,%ax 10bf7a: 0b 81 94 00 00 00 or 0x94(%ecx),%eax 10bf80: 66 a3 10 e7 11 00 mov %ax,0x11e710 _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10bf86: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax 10bf8c: 8d 50 04 lea 0x4(%eax),%edx 10bf8f: 89 11 mov %edx,(%ecx) 10bf91: 8b 50 08 mov 0x8(%eax),%edx 10bf94: 89 48 08 mov %ecx,0x8(%eax) 10bf97: 89 0a mov %ecx,(%edx) 10bf99: 89 51 04 mov %edx,0x4(%ecx) _ISR_Flash( level ); 10bf9c: 53 push %ebx 10bf9d: 9d popf 10bf9e: fa cli * 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 ) { 10bf9f: 8b 51 14 mov 0x14(%ecx),%edx 10bfa2: a1 e8 e6 11 00 mov 0x11e6e8,%eax 10bfa7: 3b 50 14 cmp 0x14(%eax),%edx 10bfaa: 73 1c jae 10bfc8 <_Thread_Clear_state+0x84> _Thread_Heir = the_thread; 10bfac: 89 0d e8 e6 11 00 mov %ecx,0x11e6e8 if ( _Thread_Executing->is_preemptible || 10bfb2: a1 1c e7 11 00 mov 0x11e71c,%eax 10bfb7: 80 78 76 00 cmpb $0x0,0x76(%eax) 10bfbb: 75 04 jne 10bfc1 <_Thread_Clear_state+0x7d> 10bfbd: 85 d2 test %edx,%edx 10bfbf: 75 07 jne 10bfc8 <_Thread_Clear_state+0x84><== ALWAYS TAKEN the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10bfc1: c6 05 2c e7 11 00 01 movb $0x1,0x11e72c } } } _ISR_Enable( level ); 10bfc8: 53 push %ebx 10bfc9: 9d popf } 10bfca: 5b pop %ebx 10bfcb: c9 leave 10bfcc: c3 ret =============================================================================== 0010bfd0 <_Thread_Close>: void _Thread_Close( Objects_Information *information, Thread_Control *the_thread ) { 10bfd0: 55 push %ebp 10bfd1: 89 e5 mov %esp,%ebp 10bfd3: 56 push %esi 10bfd4: 53 push %ebx 10bfd5: 8b 5d 08 mov 0x8(%ebp),%ebx 10bfd8: 8b 75 0c mov 0xc(%ebp),%esi 10bfdb: 0f b7 56 08 movzwl 0x8(%esi),%edx 10bfdf: 8b 43 1c mov 0x1c(%ebx),%eax 10bfe2: c7 04 90 00 00 00 00 movl $0x0,(%eax,%edx,4) 10bfe9: a1 58 e6 11 00 mov 0x11e658,%eax 10bfee: 48 dec %eax 10bfef: a3 58 e6 11 00 mov %eax,0x11e658 * disappear and set a transient state on it. So we temporarily * unnest dispatching. */ _Thread_Unnest_dispatch(); _User_extensions_Thread_delete( the_thread ); 10bff4: 83 ec 0c sub $0xc,%esp 10bff7: 56 push %esi 10bff8: e8 3f 11 00 00 call 10d13c <_User_extensions_Thread_delete> /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10bffd: a1 58 e6 11 00 mov 0x11e658,%eax 10c002: 40 inc %eax 10c003: a3 58 e6 11 00 mov %eax,0x11e658 /* * 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 ); 10c008: 59 pop %ecx 10c009: 58 pop %eax 10c00a: 56 push %esi 10c00b: 53 push %ebx 10c00c: e8 23 f6 ff ff call 10b634 <_Objects_Close> /* * 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 ); 10c011: 58 pop %eax 10c012: 5a pop %edx 10c013: 6a 01 push $0x1 10c015: 56 push %esi 10c016: e8 85 0b 00 00 call 10cba0 <_Thread_Set_state> if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 10c01b: 89 34 24 mov %esi,(%esp) 10c01e: e8 a5 09 00 00 call 10c9c8 <_Thread_queue_Extract_with_proxy> 10c023: 83 c4 10 add $0x10,%esp 10c026: 84 c0 test %al,%al 10c028: 75 06 jne 10c030 <_Thread_Close+0x60> if ( _Watchdog_Is_active( &the_thread->Timer ) ) 10c02a: 83 7e 50 02 cmpl $0x2,0x50(%esi) 10c02e: 74 68 je 10c098 <_Thread_Close+0xc8> /* * 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 ) ) 10c030: 3b 35 e0 e6 11 00 cmp 0x11e6e0,%esi 10c036: 74 74 je 10c0ac <_Thread_Close+0xdc> _Thread_Deallocate_fp(); #endif the_thread->fp_context = NULL; 10c038: c7 86 ec 00 00 00 00 movl $0x0,0xec(%esi) 10c03f: 00 00 00 if ( the_thread->Start.fp_context ) 10c042: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax 10c048: 85 c0 test %eax,%eax 10c04a: 74 0c je 10c058 <_Thread_Close+0x88> (void) _Workspace_Free( the_thread->Start.fp_context ); 10c04c: 83 ec 0c sub $0xc,%esp 10c04f: 50 push %eax 10c050: e8 b3 13 00 00 call 10d408 <_Workspace_Free> 10c055: 83 c4 10 add $0x10,%esp /* * Free the rest of the memory associated with this task * and set the associated pointers to NULL for safety. */ _Thread_Stack_Free( the_thread ); 10c058: 83 ec 0c sub $0xc,%esp 10c05b: 56 push %esi 10c05c: e8 ef 0c 00 00 call 10cd50 <_Thread_Stack_Free> the_thread->Start.stack = NULL; 10c061: c7 86 d0 00 00 00 00 movl $0x0,0xd0(%esi) 10c068: 00 00 00 if ( the_thread->extensions ) 10c06b: 8b 86 00 01 00 00 mov 0x100(%esi),%eax 10c071: 83 c4 10 add $0x10,%esp 10c074: 85 c0 test %eax,%eax 10c076: 74 0c je 10c084 <_Thread_Close+0xb4> (void) _Workspace_Free( the_thread->extensions ); 10c078: 83 ec 0c sub $0xc,%esp 10c07b: 50 push %eax 10c07c: e8 87 13 00 00 call 10d408 <_Workspace_Free> 10c081: 83 c4 10 add $0x10,%esp the_thread->extensions = NULL; 10c084: c7 86 00 01 00 00 00 movl $0x0,0x100(%esi) 10c08b: 00 00 00 } 10c08e: 8d 65 f8 lea -0x8(%ebp),%esp 10c091: 5b pop %ebx 10c092: 5e pop %esi 10c093: c9 leave 10c094: c3 ret 10c095: 8d 76 00 lea 0x0(%esi),%esi */ _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 ); 10c098: 83 ec 0c sub $0xc,%esp 10c09b: 8d 46 48 lea 0x48(%esi),%eax 10c09e: 50 push %eax 10c09f: e8 88 12 00 00 call 10d32c <_Watchdog_Remove> 10c0a4: 83 c4 10 add $0x10,%esp 10c0a7: eb 87 jmp 10c030 <_Thread_Close+0x60> 10c0a9: 8d 76 00 lea 0x0(%esi),%esi * @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( 10c0ac: c7 05 e0 e6 11 00 00 movl $0x0,0x11e6e0 10c0b3: 00 00 00 10c0b6: eb 80 jmp 10c038 <_Thread_Close+0x68> =============================================================================== 0010c0b8 <_Thread_Create_idle>: * * _Thread_Create_idle */ void _Thread_Create_idle( void ) { 10c0b8: 55 push %ebp 10c0b9: 89 e5 mov %esp,%ebp 10c0bb: 83 ec 14 sub $0x14,%esp 10c0be: 68 e0 e7 11 00 push $0x11e7e0 10c0c3: e8 ec f4 ff ff call 10b5b4 <_Objects_Allocate> /* * 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(); 10c0c8: a3 2c e8 11 00 mov %eax,0x11e82c /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10c0cd: a1 58 e6 11 00 mov 0x11e658,%eax 10c0d2: 40 inc %eax 10c0d3: a3 58 e6 11 00 mov %eax,0x11e658 * that when _Thread_Initialize unnests dispatch that we do not * do anything stupid. */ _Thread_Disable_dispatch(); _Thread_Initialize( 10c0d8: a1 f4 e6 11 00 mov 0x11e6f4,%eax 10c0dd: 8b 50 18 mov 0x18(%eax),%edx 10c0e0: 83 c4 0c add $0xc,%esp 10c0e3: 68 90 86 11 00 push $0x118690 10c0e8: 6a 00 push $0x0 10c0ea: 6a 00 push $0x0 10c0ec: 6a 00 push $0x0 10c0ee: 6a 01 push $0x1 10c0f0: 0f b6 05 14 a1 11 00 movzbl 0x11a114,%eax 10c0f7: 50 push %eax 10c0f8: 6a 00 push $0x0 10c0fa: a1 10 a1 11 00 mov 0x11a110,%eax 10c0ff: 39 d0 cmp %edx,%eax 10c101: 73 02 jae 10c105 <_Thread_Create_idle+0x4d><== ALWAYS TAKEN 10c103: 89 d0 mov %edx,%eax <== NOT EXECUTED 10c105: 50 push %eax 10c106: 6a 00 push $0x0 10c108: ff 35 2c e8 11 00 pushl 0x11e82c 10c10e: 68 e0 e7 11 00 push $0x11e7e0 10c113: e8 78 02 00 00 call 10c390 <_Thread_Initialize> 10c118: a1 58 e6 11 00 mov 0x11e658,%eax 10c11d: 48 dec %eax 10c11e: a3 58 e6 11 00 mov %eax,0x11e658 /* * WARNING!!! This is necessary to "kick" start the system and * MUST be done before _Thread_Start is invoked. */ _Thread_Heir = 10c123: 8b 15 2c e8 11 00 mov 0x11e82c,%edx 10c129: 89 15 1c e7 11 00 mov %edx,0x11e71c 10c12f: 89 15 e8 e6 11 00 mov %edx,0x11e6e8 _Thread_Executing = _Thread_Idle; _Thread_Start( 10c135: 83 c4 24 add $0x24,%esp 10c138: 6a 00 push $0x0 10c13a: 6a 00 push $0x0 10c13c: a1 f4 e6 11 00 mov 0x11e6f4,%eax 10c141: ff 70 14 pushl 0x14(%eax) 10c144: 6a 00 push $0x0 10c146: 52 push %edx 10c147: e8 9c 0c 00 00 call 10cde8 <_Thread_Start> 10c14c: 83 c4 20 add $0x20,%esp _Configuration_Table->idle_task, NULL, 0 ); } 10c14f: c9 leave 10c150: c3 ret =============================================================================== 0010c154 <_Thread_Delay_ended>: void _Thread_Delay_ended( Objects_Id id, void *ignored ) { 10c154: 55 push %ebp 10c155: 89 e5 mov %esp,%ebp 10c157: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10c15a: 8d 45 fc lea -0x4(%ebp),%eax 10c15d: 50 push %eax 10c15e: ff 75 08 pushl 0x8(%ebp) 10c161: e8 aa 01 00 00 call 10c310 <_Thread_Get> switch ( location ) { 10c166: 83 c4 10 add $0x10,%esp 10c169: 8b 55 fc mov -0x4(%ebp),%edx 10c16c: 85 d2 test %edx,%edx 10c16e: 75 1c jne 10c18c <_Thread_Delay_ended+0x38><== NEVER TAKEN void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10c170: 83 ec 08 sub $0x8,%esp 10c173: 68 f8 ff 03 10 push $0x1003fff8 10c178: 50 push %eax 10c179: e8 c6 fd ff ff call 10bf44 <_Thread_Clear_state> 10c17e: a1 58 e6 11 00 mov 0x11e658,%eax 10c183: 48 dec %eax 10c184: a3 58 e6 11 00 mov %eax,0x11e658 10c189: 83 c4 10 add $0x10,%esp case OBJECTS_LOCAL: _Thread_Unblock( the_thread ); _Thread_Unnest_dispatch(); break; } } 10c18c: c9 leave 10c18d: c3 ret =============================================================================== 0010c190 <_Thread_Dispatch>: * dispatch thread * no dispatch thread */ void _Thread_Dispatch( void ) { 10c190: 55 push %ebp 10c191: 89 e5 mov %esp,%ebp 10c193: 57 push %edi 10c194: 56 push %esi 10c195: 53 push %ebx 10c196: 83 ec 1c sub $0x1c,%esp Thread_Control *executing; Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; 10c199: 8b 35 1c e7 11 00 mov 0x11e71c,%esi _ISR_Disable( level ); 10c19f: 9c pushf 10c1a0: fa cli 10c1a1: 5a pop %edx while ( _Context_Switch_necessary == TRUE ) { 10c1a2: a0 2c e7 11 00 mov 0x11e72c,%al 10c1a7: 84 c0 test %al,%al 10c1a9: 0f 84 11 01 00 00 je 10c2c0 <_Thread_Dispatch+0x130> 10c1af: 8d 7d e4 lea -0x1c(%ebp),%edi 10c1b2: e9 d2 00 00 00 jmp 10c289 <_Thread_Dispatch+0xf9> 10c1b7: 90 nop 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 ); 10c1b8: 52 push %edx 10c1b9: 9d popf #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS { struct timespec uptime, ran; _TOD_Get_uptime( &uptime ); 10c1ba: 83 ec 0c sub $0xc,%esp 10c1bd: 8d 45 ec lea -0x14(%ebp),%eax 10c1c0: 50 push %eax 10c1c1: e8 ae 30 00 00 call 10f274 <_TOD_Get_uptime> _Timespec_Subtract(&_Thread_Time_of_last_context_switch, &uptime, &ran); 10c1c6: 83 c4 0c add $0xc,%esp 10c1c9: 57 push %edi 10c1ca: 8d 45 ec lea -0x14(%ebp),%eax 10c1cd: 50 push %eax 10c1ce: 68 24 e7 11 00 push $0x11e724 10c1d3: e8 7c 0d 00 00 call 10cf54 <_Timespec_Subtract> _Timespec_Add_to( &executing->cpu_time_used, &ran ); 10c1d8: 58 pop %eax 10c1d9: 5a pop %edx 10c1da: 57 push %edi 10c1db: 8d 86 84 00 00 00 lea 0x84(%esi),%eax 10c1e1: 50 push %eax 10c1e2: e8 35 0d 00 00 call 10cf1c <_Timespec_Add_to> _Thread_Time_of_last_context_switch = uptime; 10c1e7: 8b 45 ec mov -0x14(%ebp),%eax 10c1ea: 8b 55 f0 mov -0x10(%ebp),%edx 10c1ed: a3 24 e7 11 00 mov %eax,0x11e724 10c1f2: 89 15 28 e7 11 00 mov %edx,0x11e728 #endif /* * Switch libc's task specific data. */ if ( _Thread_libc_reent ) { 10c1f8: 8b 15 e4 e6 11 00 mov 0x11e6e4,%edx 10c1fe: 83 c4 10 add $0x10,%esp 10c201: 85 d2 test %edx,%edx 10c203: 74 10 je 10c215 <_Thread_Dispatch+0x85> <== NEVER TAKEN executing->libc_reent = *_Thread_libc_reent; 10c205: 8b 02 mov (%edx),%eax 10c207: 89 86 f0 00 00 00 mov %eax,0xf0(%esi) *_Thread_libc_reent = heir->libc_reent; 10c20d: 8b 83 f0 00 00 00 mov 0xf0(%ebx),%eax 10c213: 89 02 mov %eax,(%edx) } _User_extensions_Thread_switch( executing, heir ); 10c215: 83 ec 08 sub $0x8,%esp 10c218: 53 push %ebx 10c219: 56 push %esi 10c21a: e8 9d 0f 00 00 call 10d1bc <_User_extensions_Thread_switch> if ( executing->fp_context != NULL ) _Context_Save_fp( &executing->fp_context ); #endif #endif _Context_Switch( &executing->Registers, &heir->Registers ); 10c21f: 59 pop %ecx 10c220: 58 pop %eax 10c221: 8d 83 d4 00 00 00 lea 0xd4(%ebx),%eax 10c227: 50 push %eax 10c228: 8d 86 d4 00 00 00 lea 0xd4(%esi),%eax 10c22e: 50 push %eax 10c22f: e8 8c 12 00 00 call 10d4c0 <_CPU_Context_switch> #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) #if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE ) if ( (executing->fp_context != NULL) && 10c234: 83 c4 10 add $0x10,%esp 10c237: 8b 96 ec 00 00 00 mov 0xec(%esi),%edx 10c23d: 85 d2 test %edx,%edx 10c23f: 74 36 je 10c277 <_Thread_Dispatch+0xe7> Heap_Control *the_heap, void *starting_address, size_t *size ); /** 10c241: a1 e0 e6 11 00 mov 0x11e6e0,%eax 10c246: 39 c6 cmp %eax,%esi 10c248: 74 2d je 10c277 <_Thread_Dispatch+0xe7> !_Thread_Is_allocated_fp( executing ) ) { if ( _Thread_Allocated_fp != NULL ) 10c24a: 85 c0 test %eax,%eax 10c24c: 74 11 je 10c25f <_Thread_Dispatch+0xcf> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 10c24e: 83 ec 0c sub $0xc,%esp 10c251: 05 ec 00 00 00 add $0xec,%eax 10c256: 50 push %eax 10c257: e8 98 12 00 00 call 10d4f4 <_CPU_Context_save_fp> 10c25c: 83 c4 10 add $0x10,%esp _Context_Restore_fp( &executing->fp_context ); 10c25f: 83 ec 0c sub $0xc,%esp 10c262: 8d 86 ec 00 00 00 lea 0xec(%esi),%eax 10c268: 50 push %eax 10c269: e8 90 12 00 00 call 10d4fe <_CPU_Context_restore_fp> _Thread_Allocated_fp = executing; 10c26e: 89 35 e0 e6 11 00 mov %esi,0x11e6e0 10c274: 83 c4 10 add $0x10,%esp if ( executing->fp_context != NULL ) _Context_Restore_fp( &executing->fp_context ); #endif #endif executing = _Thread_Executing; 10c277: 8b 35 1c e7 11 00 mov 0x11e71c,%esi _ISR_Disable( level ); 10c27d: 9c pushf 10c27e: fa cli 10c27f: 5a pop %edx Thread_Control *heir; ISR_Level level; executing = _Thread_Executing; _ISR_Disable( level ); while ( _Context_Switch_necessary == TRUE ) { 10c280: a0 2c e7 11 00 mov 0x11e72c,%al 10c285: 84 c0 test %al,%al 10c287: 74 37 je 10c2c0 <_Thread_Dispatch+0x130> heir = _Thread_Heir; 10c289: 8b 1d e8 e6 11 00 mov 0x11e6e8,%ebx _Thread_Dispatch_disable_level = 1; 10c28f: c7 05 58 e6 11 00 01 movl $0x1,0x11e658 10c296: 00 00 00 _Context_Switch_necessary = FALSE; 10c299: c6 05 2c e7 11 00 00 movb $0x0,0x11e72c _Thread_Executing = heir; 10c2a0: 89 1d 1c e7 11 00 mov %ebx,0x11e71c #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 ) 10c2a6: 83 7b 7c 01 cmpl $0x1,0x7c(%ebx) 10c2aa: 0f 85 08 ff ff ff jne 10c1b8 <_Thread_Dispatch+0x28> heir->cpu_time_budget = _Thread_Ticks_per_timeslice; 10c2b0: a1 24 e6 11 00 mov 0x11e624,%eax 10c2b5: 89 43 78 mov %eax,0x78(%ebx) 10c2b8: e9 fb fe ff ff jmp 10c1b8 <_Thread_Dispatch+0x28> 10c2bd: 8d 76 00 lea 0x0(%esi),%esi executing = _Thread_Executing; _ISR_Disable( level ); } _Thread_Dispatch_disable_level = 0; 10c2c0: c7 05 58 e6 11 00 00 movl $0x0,0x11e658 10c2c7: 00 00 00 _ISR_Enable( level ); 10c2ca: 52 push %edx 10c2cb: 9d popf if ( _Thread_Do_post_task_switch_extension || 10c2cc: a1 00 e7 11 00 mov 0x11e700,%eax 10c2d1: 85 c0 test %eax,%eax 10c2d3: 75 06 jne 10c2db <_Thread_Dispatch+0x14b><== NEVER TAKEN 10c2d5: 80 7e 75 00 cmpb $0x0,0x75(%esi) 10c2d9: 74 09 je 10c2e4 <_Thread_Dispatch+0x154> executing->do_post_task_switch_extension ) { executing->do_post_task_switch_extension = false; 10c2db: c6 46 75 00 movb $0x0,0x75(%esi) _API_extensions_Run_postswitch(); 10c2df: e8 74 e9 ff ff call 10ac58 <_API_extensions_Run_postswitch> } } 10c2e4: 8d 65 f4 lea -0xc(%ebp),%esp 10c2e7: 5b pop %ebx 10c2e8: 5e pop %esi 10c2e9: 5f pop %edi 10c2ea: c9 leave 10c2eb: c3 ret =============================================================================== 0010c2ec <_Thread_Enable_dispatch>: */ #if ( (CPU_INLINE_ENABLE_DISPATCH == FALSE) || \ (__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) ) void _Thread_Enable_dispatch( void ) { 10c2ec: 55 push %ebp 10c2ed: 89 e5 mov %esp,%ebp if ( --_Thread_Dispatch_disable_level ) 10c2ef: a1 58 e6 11 00 mov 0x11e658,%eax 10c2f4: 48 dec %eax 10c2f5: a3 58 e6 11 00 mov %eax,0x11e658 10c2fa: a1 58 e6 11 00 mov 0x11e658,%eax 10c2ff: 85 c0 test %eax,%eax 10c301: 74 05 je 10c308 <_Thread_Enable_dispatch+0x1c> return; _Thread_Dispatch(); } 10c303: c9 leave 10c304: c3 ret 10c305: 8d 76 00 lea 0x0(%esi),%esi 10c308: c9 leave (__RTEMS_DO_NOT_INLINE_THREAD_ENABLE_DISPATCH__ == 1) ) void _Thread_Enable_dispatch( void ) { if ( --_Thread_Dispatch_disable_level ) return; _Thread_Dispatch(); 10c309: e9 82 fe ff ff jmp 10c190 <_Thread_Dispatch> =============================================================================== 0010ffe8 <_Thread_Evaluate_mode>: * * XXX */ bool _Thread_Evaluate_mode( void ) { 10ffe8: 55 push %ebp 10ffe9: 89 e5 mov %esp,%ebp Thread_Control *executing; executing = _Thread_Executing; 10ffeb: a1 1c e7 11 00 mov 0x11e71c,%eax if ( !_States_Is_ready( executing->current_state ) || 10fff0: 8b 50 10 mov 0x10(%eax),%edx 10fff3: 85 d2 test %edx,%edx 10fff5: 75 0e jne 110005 <_Thread_Evaluate_mode+0x1d><== NEVER TAKEN 10fff7: 3b 05 e8 e6 11 00 cmp 0x11e6e8,%eax 10fffd: 74 11 je 110010 <_Thread_Evaluate_mode+0x28> 10ffff: 80 78 76 00 cmpb $0x0,0x76(%eax) 110003: 74 0b je 110010 <_Thread_Evaluate_mode+0x28><== NEVER TAKEN ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; 110005: c6 05 2c e7 11 00 01 movb $0x1,0x11e72c 11000c: b0 01 mov $0x1,%al return TRUE; } return FALSE; } 11000e: c9 leave 11000f: c3 ret executing = _Thread_Executing; if ( !_States_Is_ready( executing->current_state ) || ( !_Thread_Is_heir( executing ) && executing->is_preemptible ) ) { _Context_Switch_necessary = TRUE; return TRUE; 110010: 31 c0 xor %eax,%eax } return FALSE; } 110012: c9 leave 110013: c3 ret =============================================================================== 0010c310 <_Thread_Get>: Thread_Control *_Thread_Get ( Objects_Id id, Objects_Locations *location ) { 10c310: 55 push %ebp 10c311: 89 e5 mov %esp,%ebp 10c313: 53 push %ebx 10c314: 83 ec 04 sub $0x4,%esp 10c317: 8b 4d 08 mov 0x8(%ebp),%ecx 10c31a: 8b 5d 0c mov 0xc(%ebp),%ebx 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 ) ) { 10c31d: 85 c9 test %ecx,%ecx 10c31f: 74 4b je 10c36c <_Thread_Get+0x5c> uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10c321: 89 ca mov %ecx,%edx 10c323: c1 ea 18 shr $0x18,%edx 10c326: 83 e2 07 and $0x7,%edx /** * 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. 10c329: 8d 42 ff lea -0x1(%edx),%eax 10c32c: 83 f8 03 cmp $0x3,%eax 10c32f: 77 2b ja 10c35c <_Thread_Get+0x4c> *location = OBJECTS_ERROR; goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ 10c331: 89 c8 mov %ecx,%eax 10c333: c1 e8 1b shr $0x1b,%eax 10c336: 48 dec %eax 10c337: 75 23 jne 10c35c <_Thread_Get+0x4c> *location = OBJECTS_ERROR; goto done; } api_information = _Objects_Information_table[ the_api ]; 10c339: 8b 04 95 2c e6 11 00 mov 0x11e62c(,%edx,4),%eax if ( !api_information ) { 10c340: 85 c0 test %eax,%eax 10c342: 74 44 je 10c388 <_Thread_Get+0x78> *location = OBJECTS_ERROR; goto done; } information = api_information[ the_class ]; 10c344: 8b 40 04 mov 0x4(%eax),%eax if ( !information ) { 10c347: 85 c0 test %eax,%eax 10c349: 74 3d je 10c388 <_Thread_Get+0x78> <== NEVER TAKEN *location = OBJECTS_ERROR; goto done; } tp = (Thread_Control *) _Objects_Get( information, id, location ); 10c34b: 52 push %edx 10c34c: 53 push %ebx 10c34d: 51 push %ecx 10c34e: 50 push %eax 10c34f: e8 54 f7 ff ff call 10baa8 <_Objects_Get> 10c354: 83 c4 10 add $0x10,%esp done: return tp; } 10c357: 8b 5d fc mov -0x4(%ebp),%ebx 10c35a: c9 leave 10c35b: c3 ret goto done; } the_class = _Objects_Get_class( id ); if ( the_class != 1 ) { /* threads are always first class :) */ *location = OBJECTS_ERROR; 10c35c: c7 03 01 00 00 00 movl $0x1,(%ebx) 10c362: 31 c0 xor %eax,%eax tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10c364: 8b 5d fc mov -0x4(%ebp),%ebx 10c367: c9 leave 10c368: c3 ret 10c369: 8d 76 00 lea 0x0(%esi),%esi /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10c36c: a1 58 e6 11 00 mov 0x11e658,%eax 10c371: 40 inc %eax 10c372: a3 58 e6 11 00 mov %eax,0x11e658 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; 10c377: c7 03 00 00 00 00 movl $0x0,(%ebx) tp = _Thread_Executing; 10c37d: a1 1c e7 11 00 mov 0x11e71c,%eax tp = (Thread_Control *) _Objects_Get( information, id, location ); done: return tp; } 10c382: 8b 5d fc mov -0x4(%ebp),%ebx 10c385: c9 leave 10c386: c3 ret 10c387: 90 nop goto done; } information = api_information[ the_class ]; if ( !information ) { *location = OBJECTS_ERROR; 10c388: c7 03 01 00 00 00 movl $0x1,(%ebx) 10c38e: eb d4 jmp 10c364 <_Thread_Get+0x54> =============================================================================== 00110014 <_Thread_Handler>: * * Output parameters: NONE */ void _Thread_Handler( void ) { 110014: 55 push %ebp 110015: 89 e5 mov %esp,%ebp 110017: 53 push %ebx 110018: 83 ec 04 sub $0x4,%esp #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) static char doneConstructors; char doneCons; #endif executing = _Thread_Executing; 11001b: 8b 1d 1c e7 11 00 mov 0x11e71c,%ebx /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 110021: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax _ISR_Set_level(level); 110027: 85 c0 test %eax,%eax 110029: 0f 84 91 00 00 00 je 1100c0 <_Thread_Handler+0xac> 11002f: fa cli #if defined(__USE_INIT_FINI__) || defined(__USE__MAIN__) doneCons = doneConstructors; 110030: a0 18 e4 11 00 mov 0x11e418,%al 110035: 88 45 fb mov %al,-0x5(%ebp) doneConstructors = 1; 110038: c6 05 18 e4 11 00 01 movb $0x1,0x11e418 #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 ) ) { 11003f: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax 110045: 85 c0 test %eax,%eax 110047: 74 24 je 11006d <_Thread_Handler+0x59> Heap_Control *the_heap, void *starting_address, size_t *size ); /** 110049: a1 e0 e6 11 00 mov 0x11e6e0,%eax 11004e: 39 c3 cmp %eax,%ebx 110050: 74 1b je 11006d <_Thread_Handler+0x59> if ( _Thread_Allocated_fp != NULL ) 110052: 85 c0 test %eax,%eax 110054: 74 11 je 110067 <_Thread_Handler+0x53> _Context_Save_fp( &_Thread_Allocated_fp->fp_context ); 110056: 83 ec 0c sub $0xc,%esp 110059: 05 ec 00 00 00 add $0xec,%eax 11005e: 50 push %eax 11005f: e8 90 d4 ff ff call 10d4f4 <_CPU_Context_save_fp> 110064: 83 c4 10 add $0x10,%esp _Thread_Allocated_fp = executing; 110067: 89 1d e0 e6 11 00 mov %ebx,0x11e6e0 * 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 ); 11006d: 83 ec 0c sub $0xc,%esp 110070: 53 push %ebx 110071: e8 be cf ff ff call 10d034 <_User_extensions_Thread_begin> /* * At this point, the dispatch disable level BETTER be 1. */ _Thread_Enable_dispatch(); 110076: e8 71 c2 ff ff call 10c2ec <_Thread_Enable_dispatch> /* * _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) */ 11007b: 83 c4 10 add $0x10,%esp 11007e: 80 7d fb 00 cmpb $0x0,-0x5(%ebp) 110082: 74 6c je 1100f0 <_Thread_Handler+0xdc> #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 110084: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax 11008a: 83 f8 01 cmp $0x1,%eax 11008d: 74 71 je 110100 <_Thread_Handler+0xec> <== NEVER TAKEN 11008f: 73 37 jae 1100c8 <_Thread_Handler+0xb4> <== NEVER TAKEN case THREAD_START_NUMERIC: executing->Wait.return_argument = 110091: 83 ec 0c sub $0xc,%esp 110094: ff b3 a8 00 00 00 pushl 0xa8(%ebx) 11009a: ff 93 9c 00 00 00 call *0x9c(%ebx) 1100a0: 89 43 28 mov %eax,0x28(%ebx) 1100a3: 83 c4 10 add $0x10,%esp * 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 ); 1100a6: 83 ec 0c sub $0xc,%esp 1100a9: 53 push %ebx 1100aa: e8 c1 cf ff ff call 10d070 <_User_extensions_Thread_exitted> _Internal_error_Occurred( 1100af: 83 c4 0c add $0xc,%esp 1100b2: 6a 06 push $0x6 1100b4: 6a 01 push $0x1 1100b6: 6a 00 push $0x0 1100b8: e8 63 b4 ff ff call 10b520 <_Internal_error_Occurred> 1100bd: 8d 76 00 lea 0x0(%esi),%esi * 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); 1100c0: fb sti 1100c1: e9 6a ff ff ff jmp 110030 <_Thread_Handler+0x1c> 1100c6: 66 90 xchg %ax,%ax #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 1100c8: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 1100cb: 74 4b je 110118 <_Thread_Handler+0x104> <== NOT EXECUTED 1100cd: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 1100d0: 75 d4 jne 1100a6 <_Thread_Handler+0x92> <== NOT EXECUTED executing->Start.pointer_argument, executing->Start.numeric_argument ); break; case THREAD_START_BOTH_NUMERIC_FIRST: executing->Wait.return_argument = 1100d2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1100d5: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 1100db: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 1100e1: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 1100e7: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 1100ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1100ed: eb b7 jmp 1100a6 <_Thread_Handler+0x92> <== NOT EXECUTED 1100ef: 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 (); 1100f0: e8 db 6d 00 00 call 116ed0 <__start_set_sysctl_set> #if defined(__USE__MAIN__) if (!doneCons && _main) __main (); #endif switch ( executing->Start.prototype ) { 1100f5: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax 1100fb: 83 f8 01 cmp $0x1,%eax 1100fe: 75 8f jne 11008f <_Thread_Handler+0x7b> <== ALWAYS TAKEN (*(Thread_Entry_numeric) executing->Start.entry_point)( executing->Start.numeric_argument ); break; case THREAD_START_POINTER: executing->Wait.return_argument = 110100: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 110103: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 110109: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 11010f: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 110112: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110115: eb 8f jmp 1100a6 <_Thread_Handler+0x92> <== NOT EXECUTED 110117: 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 = 110118: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 11011b: ff b3 a8 00 00 00 pushl 0xa8(%ebx) <== NOT EXECUTED 110121: ff b3 a4 00 00 00 pushl 0xa4(%ebx) <== NOT EXECUTED 110127: ff 93 9c 00 00 00 call *0x9c(%ebx) <== NOT EXECUTED 11012d: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 110130: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 110133: e9 6e ff ff ff jmp 1100a6 <_Thread_Handler+0x92> <== NOT EXECUTED =============================================================================== 0010c390 <_Thread_Initialize>: Thread_CPU_budget_algorithms budget_algorithm, Thread_CPU_budget_algorithm_callout budget_callout, uint32_t isr_level, Objects_Name name ) { 10c390: 55 push %ebp 10c391: 89 e5 mov %esp,%ebp 10c393: 57 push %edi 10c394: 56 push %esi 10c395: 53 push %ebx 10c396: 83 ec 0c sub $0xc,%esp 10c399: 8b 5d 0c mov 0xc(%ebp),%ebx 10c39c: 8b 55 10 mov 0x10(%ebp),%edx 10c39f: 8a 45 18 mov 0x18(%ebp),%al 10c3a2: 88 45 f3 mov %al,-0xd(%ebp) 10c3a5: 8a 4d 20 mov 0x20(%ebp),%cl 10c3a8: 88 4d f2 mov %cl,-0xe(%ebp) /* * Allocate and Initialize the stack for this thread. */ if ( !stack_area ) { 10c3ab: 85 d2 test %edx,%edx 10c3ad: 0f 84 b2 01 00 00 je 10c565 <_Thread_Initialize+0x1d5><== ALWAYS TAKEN 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; 10c3b3: c6 83 c0 00 00 00 00 movb $0x0,0xc0(%ebx) <== NOT EXECUTED 10c3ba: 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 10c3bd: 89 93 c8 00 00 00 mov %edx,0xc8(%ebx) * CPU_ALIGNMENT, it's aligned up to the nearest CPU_ALIGNMENT boundary. 10c3c3: 89 83 c4 00 00 00 mov %eax,0xc4(%ebx) /* * Allocate the floating point area for this thread */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { 10c3c9: 80 7d f3 00 cmpb $0x0,-0xd(%ebp) 10c3cd: 0f 85 2d 01 00 00 jne 10c500 <_Thread_Initialize+0x170> fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); if ( !fp_area ) { _Thread_Stack_Free( the_thread ); return FALSE; 10c3d3: 31 ff xor %edi,%edi 10c3d5: 31 c0 xor %eax,%eax fp_area = _Context_Fp_start( fp_area, 0 ); } else fp_area = NULL; the_thread->fp_context = fp_area; 10c3d7: 89 83 ec 00 00 00 mov %eax,0xec(%ebx) the_thread->Start.fp_context = fp_area; 10c3dd: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) * 10c3e3: c7 43 50 00 00 00 00 movl $0x0,0x50(%ebx) * @param[in] the_heap is the heap to operate upon 10c3ea: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) * @param[in] starting_address is the starting address of the memory for 10c3f1: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx) * the heap 10c3f8: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) /* * Clear the libc reent hook. */ the_thread->libc_reent = NULL; 10c3ff: c7 83 f0 00 00 00 00 movl $0x0,0xf0(%ebx) 10c406: 00 00 00 /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { 10c409: a1 fc e6 11 00 mov 0x11e6fc,%eax 10c40e: 85 c0 test %eax,%eax 10c410: 0f 85 06 01 00 00 jne 10c51c <_Thread_Initialize+0x18c> return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 10c416: c7 83 00 01 00 00 00 movl $0x0,0x100(%ebx) 10c41d: 00 00 00 10c420: 31 f6 xor %esi,%esi /* * General initialization */ the_thread->Start.is_preemptible = is_preemptible; 10c422: 8a 45 f2 mov -0xe(%ebp),%al 10c425: 88 83 ac 00 00 00 mov %al,0xac(%ebx) the_thread->Start.budget_algorithm = budget_algorithm; 10c42b: 8b 4d 24 mov 0x24(%ebp),%ecx 10c42e: 89 8b b0 00 00 00 mov %ecx,0xb0(%ebx) the_thread->Start.budget_callout = budget_callout; 10c434: 8b 45 28 mov 0x28(%ebp),%eax 10c437: 89 83 b4 00 00 00 mov %eax,0xb4(%ebx) switch ( budget_algorithm ) { 10c43d: 83 f9 02 cmp $0x2,%ecx 10c440: 75 08 jne 10c44a <_Thread_Initialize+0xba><== ALWAYS TAKEN 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; 10c442: a1 24 e6 11 00 mov 0x11e624,%eax <== NOT EXECUTED 10c447: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: break; } the_thread->Start.isr_level = isr_level; 10c44a: 8b 4d 2c mov 0x2c(%ebp),%ecx 10c44d: 89 8b b8 00 00 00 mov %ecx,0xb8(%ebx) the_thread->current_state = STATES_DORMANT; 10c453: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx) the_thread->Wait.queue = NULL; 10c45a: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) the_thread->resource_count = 0; 10c461: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->suspend_count = 0; 10c468: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) the_thread->real_priority = priority; 10c46f: 8b 45 1c mov 0x1c(%ebp),%eax 10c472: 89 43 18 mov %eax,0x18(%ebx) the_thread->Start.initial_priority = priority; 10c475: 89 83 bc 00 00 00 mov %eax,0xbc(%ebx) _Thread_Set_priority( the_thread, priority ); 10c47b: 83 ec 08 sub $0x8,%esp 10c47e: 50 push %eax 10c47f: 53 push %ebx 10c480: e8 af 06 00 00 call 10cb34 <_Thread_Set_priority> /* * Initialize the CPU usage statistics */ #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS the_thread->cpu_time_used.tv_sec = 0; 10c485: c7 83 84 00 00 00 00 movl $0x0,0x84(%ebx) 10c48c: 00 00 00 the_thread->cpu_time_used.tv_nsec = 0; 10c48f: c7 83 88 00 00 00 00 movl $0x0,0x88(%ebx) 10c496: 00 00 00 10c499: 0f b7 53 08 movzwl 0x8(%ebx),%edx 10c49d: 8b 4d 08 mov 0x8(%ebp),%ecx 10c4a0: 8b 41 1c mov 0x1c(%ecx),%eax 10c4a3: 89 1c 90 mov %ebx,(%eax,%edx,4) 10c4a6: 8b 45 30 mov 0x30(%ebp),%eax 10c4a9: 89 43 0c mov %eax,0xc(%ebx) * 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 ); 10c4ac: 89 1c 24 mov %ebx,(%esp) 10c4af: e8 40 0c 00 00 call 10d0f4 <_User_extensions_Thread_create> if ( !extension_status ) { 10c4b4: 83 c4 10 add $0x10,%esp 10c4b7: 84 c0 test %al,%al 10c4b9: 75 39 jne 10c4f4 <_Thread_Initialize+0x164><== ALWAYS TAKEN if ( extensions_area ) 10c4bb: 85 f6 test %esi,%esi <== NOT EXECUTED 10c4bd: 74 0c je 10c4cb <_Thread_Initialize+0x13b><== NOT EXECUTED (void) _Workspace_Free( extensions_area ); 10c4bf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c4c2: 56 push %esi <== NOT EXECUTED 10c4c3: e8 40 0f 00 00 call 10d408 <_Workspace_Free> <== NOT EXECUTED 10c4c8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( fp_area ) 10c4cb: 85 ff test %edi,%edi <== NOT EXECUTED 10c4cd: 74 0c je 10c4db <_Thread_Initialize+0x14b><== NOT EXECUTED (void) _Workspace_Free( fp_area ); 10c4cf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c4d2: 57 push %edi <== NOT EXECUTED 10c4d3: e8 30 0f 00 00 call 10d408 <_Workspace_Free> <== NOT EXECUTED 10c4d8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED #endif _Thread_Stack_Free( the_thread ); 10c4db: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10c4de: 53 push %ebx <== NOT EXECUTED 10c4df: e8 6c 08 00 00 call 10cd50 <_Thread_Stack_Free> <== NOT EXECUTED 10c4e4: 31 c0 xor %eax,%eax <== NOT EXECUTED 10c4e6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return FALSE; } return TRUE; } 10c4e9: 8d 65 f4 lea -0xc(%ebp),%esp 10c4ec: 5b pop %ebx 10c4ed: 5e pop %esi 10c4ee: 5f pop %edi 10c4ef: c9 leave 10c4f0: c3 ret 10c4f1: 8d 76 00 lea 0x0(%esi),%esi * Mutex provides sufficient protection to let the user extensions * run safely. */ extension_status = _User_extensions_Thread_create( the_thread ); if ( !extension_status ) { 10c4f4: b0 01 mov $0x1,%al return FALSE; } return TRUE; } 10c4f6: 8d 65 f4 lea -0xc(%ebp),%esp 10c4f9: 5b pop %ebx 10c4fa: 5e pop %esi 10c4fb: 5f pop %edi 10c4fc: c9 leave 10c4fd: c3 ret 10c4fe: 66 90 xchg %ax,%ax */ #if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE ) if ( is_fp ) { fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE ); 10c500: 83 ec 0c sub $0xc,%esp 10c503: 6a 6c push $0x6c 10c505: e8 16 0f 00 00 call 10d420 <_Workspace_Allocate> 10c50a: 89 c7 mov %eax,%edi if ( !fp_area ) { 10c50c: 83 c4 10 add $0x10,%esp 10c50f: 85 c0 test %eax,%eax 10c511: 0f 85 c0 fe ff ff jne 10c3d7 <_Thread_Initialize+0x47><== ALWAYS TAKEN 10c517: eb c2 jmp 10c4db <_Thread_Initialize+0x14b><== NOT EXECUTED 10c519: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Allocate the extensions area for this thread */ if ( _Thread_Maximum_extensions ) { extensions_area = _Workspace_Allocate( 10c51c: 83 ec 0c sub $0xc,%esp 10c51f: 8d 04 85 04 00 00 00 lea 0x4(,%eax,4),%eax 10c526: 50 push %eax 10c527: e8 f4 0e 00 00 call 10d420 <_Workspace_Allocate> 10c52c: 89 c6 mov %eax,%esi (_Thread_Maximum_extensions + 1) * sizeof( void * ) ); if ( !extensions_area ) { 10c52e: 83 c4 10 add $0x10,%esp 10c531: 85 c0 test %eax,%eax 10c533: 74 96 je 10c4cb <_Thread_Initialize+0x13b><== NEVER TAKEN return FALSE; } } else extensions_area = NULL; the_thread->extensions = (void **) extensions_area; 10c535: 89 83 00 01 00 00 mov %eax,0x100(%ebx) * call. */ if ( the_thread->extensions ) { uint32_t i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 10c53b: 83 3d fc e6 11 00 ff cmpl $0xffffffff,0x11e6fc 10c542: 0f 84 da fe ff ff je 10c422 <_Thread_Initialize+0x92><== NEVER TAKEN 10c548: 31 d2 xor %edx,%edx 10c54a: 89 c1 mov %eax,%ecx 10c54c: a1 fc e6 11 00 mov 0x11e6fc,%eax 10c551: 40 inc %eax 10c552: 66 90 xchg %ax,%ax the_thread->extensions[i] = NULL; 10c554: c7 04 91 00 00 00 00 movl $0x0,(%ecx,%edx,4) * call. */ if ( the_thread->extensions ) { uint32_t i; for ( i = 0; i < (_Thread_Maximum_extensions + 1); i++ ) 10c55b: 42 inc %edx 10c55c: 39 d0 cmp %edx,%eax 10c55e: 77 f4 ja 10c554 <_Thread_Initialize+0x1c4> 10c560: e9 bd fe ff ff jmp 10c422 <_Thread_Initialize+0x92> */ if ( !stack_area ) { actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size ); 10c565: 83 ec 08 sub $0x8,%esp 10c568: ff 75 14 pushl 0x14(%ebp) 10c56b: 53 push %ebx 10c56c: e8 7b 07 00 00 call 10ccec <_Thread_Stack_Allocate> if ( !actual_stack_size || actual_stack_size < stack_size ) 10c571: 83 c4 10 add $0x10,%esp 10c574: 85 c0 test %eax,%eax 10c576: 74 17 je 10c58f <_Thread_Initialize+0x1ff> 10c578: 39 45 14 cmp %eax,0x14(%ebp) 10c57b: 77 12 ja 10c58f <_Thread_Initialize+0x1ff><== NEVER TAKEN return FALSE; /* stack allocation failed */ stack = the_thread->Start.stack; 10c57d: 8b 93 d0 00 00 00 mov 0xd0(%ebx),%edx the_thread->Start.core_allocated_stack = TRUE; 10c583: c6 83 c0 00 00 00 01 movb $0x1,0xc0(%ebx) 10c58a: e9 2e fe ff ff jmp 10c3bd <_Thread_Initialize+0x2d> (void) _Workspace_Free( fp_area ); #endif _Thread_Stack_Free( the_thread ); return FALSE; 10c58f: 31 c0 xor %eax,%eax 10c591: e9 53 ff ff ff jmp 10c4e9 <_Thread_Initialize+0x159> =============================================================================== 001103d0 <_Thread_Reset>: void _Thread_Reset( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 1103d0: 55 push %ebp 1103d1: 89 e5 mov %esp,%ebp 1103d3: 53 push %ebx 1103d4: 83 ec 10 sub $0x10,%esp 1103d7: 8b 5d 08 mov 0x8(%ebp),%ebx the_thread->resource_count = 0; 1103da: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) the_thread->suspend_count = 0; 1103e1: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) the_thread->is_preemptible = the_thread->Start.is_preemptible; 1103e8: 8a 83 ac 00 00 00 mov 0xac(%ebx),%al 1103ee: 88 43 76 mov %al,0x76(%ebx) the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 1103f1: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax 1103f7: 89 43 7c mov %eax,0x7c(%ebx) the_thread->budget_callout = the_thread->Start.budget_callout; 1103fa: 8b 83 b4 00 00 00 mov 0xb4(%ebx),%eax 110400: 89 83 80 00 00 00 mov %eax,0x80(%ebx) the_thread->Start.pointer_argument = pointer_argument; 110406: 8b 45 0c mov 0xc(%ebp),%eax 110409: 89 83 a4 00 00 00 mov %eax,0xa4(%ebx) the_thread->Start.numeric_argument = numeric_argument; 11040f: 8b 45 10 mov 0x10(%ebp),%eax 110412: 89 83 a8 00 00 00 mov %eax,0xa8(%ebx) if ( !_Thread_queue_Extract_with_proxy( the_thread ) ) { 110418: 53 push %ebx 110419: e8 e2 cf ff ff call 10d400 <_Thread_queue_Extract_with_proxy> 11041e: 83 c4 10 add $0x10,%esp 110421: 84 c0 test %al,%al 110423: 75 06 jne 11042b <_Thread_Reset+0x5b> <== NEVER TAKEN if ( _Watchdog_Is_active( &the_thread->Timer ) ) 110425: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 110429: 74 25 je 110450 <_Thread_Reset+0x80> (void) _Watchdog_Remove( &the_thread->Timer ); } if ( the_thread->current_priority != the_thread->Start.initial_priority ) { 11042b: 8b 83 bc 00 00 00 mov 0xbc(%ebx),%eax 110431: 39 43 14 cmp %eax,0x14(%ebx) 110434: 74 12 je 110448 <_Thread_Reset+0x78> the_thread->real_priority = the_thread->Start.initial_priority; 110436: 89 43 18 mov %eax,0x18(%ebx) _Thread_Set_priority( the_thread, the_thread->Start.initial_priority ); 110439: 89 45 0c mov %eax,0xc(%ebp) 11043c: 89 5d 08 mov %ebx,0x8(%ebp) } } 11043f: 8b 5d fc mov -0x4(%ebp),%ebx 110442: c9 leave (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 ); 110443: e9 b8 d1 ff ff jmp 10d600 <_Thread_Set_priority> } } 110448: 8b 5d fc mov -0x4(%ebp),%ebx 11044b: c9 leave 11044c: c3 ret 11044d: 8d 76 00 lea 0x0(%esi),%esi 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 ); 110450: 83 ec 0c sub $0xc,%esp 110453: 8d 43 48 lea 0x48(%ebx),%eax 110456: 50 push %eax 110457: e8 dc d9 ff ff call 10de38 <_Watchdog_Remove> 11045c: 83 c4 10 add $0x10,%esp 11045f: eb ca jmp 11042b <_Thread_Reset+0x5b> =============================================================================== 0010f828 <_Thread_Reset_timeslice>: * ready chain * select heir */ void _Thread_Reset_timeslice( void ) { 10f828: 55 push %ebp 10f829: 89 e5 mov %esp,%ebp 10f82b: 56 push %esi 10f82c: 53 push %ebx ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10f82d: 8b 0d 1c e7 11 00 mov 0x11e71c,%ecx ready = executing->ready; 10f833: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx _ISR_Disable( level ); 10f839: 9c pushf 10f83a: fa cli 10f83b: 5e pop %esi if ( _Chain_Has_only_one_node( ready ) ) { 10f83c: 8b 03 mov (%ebx),%eax 10f83e: 3b 43 08 cmp 0x8(%ebx),%eax 10f841: 74 35 je 10f878 <_Thread_Reset_timeslice+0x50> 10f843: 8b 11 mov (%ecx),%edx 10f845: 8b 41 04 mov 0x4(%ecx),%eax 10f848: 89 42 04 mov %eax,0x4(%edx) 10f84b: 89 10 mov %edx,(%eax) 10f84d: 8d 43 04 lea 0x4(%ebx),%eax 10f850: 89 01 mov %eax,(%ecx) 10f852: 8b 43 08 mov 0x8(%ebx),%eax 10f855: 89 4b 08 mov %ecx,0x8(%ebx) 10f858: 89 08 mov %ecx,(%eax) 10f85a: 89 41 04 mov %eax,0x4(%ecx) return; } _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 10f85d: 56 push %esi 10f85e: 9d popf 10f85f: fa cli if ( _Thread_Is_heir( executing ) ) 10f860: 3b 0d e8 e6 11 00 cmp 0x11e6e8,%ecx 10f866: 74 18 je 10f880 <_Thread_Reset_timeslice+0x58><== ALWAYS TAKEN _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; 10f868: c6 05 2c e7 11 00 01 movb $0x1,0x11e72c _ISR_Enable( level ); 10f86f: 56 push %esi 10f870: 9d popf } 10f871: 5b pop %ebx 10f872: 5e pop %esi 10f873: c9 leave 10f874: c3 ret 10f875: 8d 76 00 lea 0x0(%esi),%esi executing = _Thread_Executing; ready = executing->ready; _ISR_Disable( level ); if ( _Chain_Has_only_one_node( ready ) ) { _ISR_Enable( level ); 10f878: 56 push %esi 10f879: 9d popf _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10f87a: 5b pop %ebx 10f87b: 5e pop %esi 10f87c: c9 leave 10f87d: c3 ret 10f87e: 66 90 xchg %ax,%ax _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; 10f880: 8b 03 mov (%ebx),%eax 10f882: a3 e8 e6 11 00 mov %eax,0x11e6e8 10f887: eb df jmp 10f868 <_Thread_Reset_timeslice+0x40> =============================================================================== 0010d56c <_Thread_Restart>: bool _Thread_Restart( Thread_Control *the_thread, void *pointer_argument, Thread_Entry_numeric_type numeric_argument ) { 10d56c: 55 push %ebp 10d56d: 89 e5 mov %esp,%ebp 10d56f: 53 push %ebx 10d570: 83 ec 04 sub $0x4,%esp 10d573: 8b 5d 08 mov 0x8(%ebp),%ebx if ( !_States_Is_dormant( the_thread->current_state ) ) { 10d576: f6 43 10 01 testb $0x1,0x10(%ebx) 10d57a: 74 08 je 10d584 <_Thread_Restart+0x18> 10d57c: 31 c0 xor %eax,%eax return TRUE; } return FALSE; } 10d57e: 8b 5d fc mov -0x4(%ebp),%ebx 10d581: c9 leave 10d582: c3 ret 10d583: 90 nop Thread_Entry_numeric_type numeric_argument ) { if ( !_States_Is_dormant( the_thread->current_state ) ) { _Thread_Set_transient( the_thread ); 10d584: 83 ec 0c sub $0xc,%esp 10d587: 53 push %ebx 10d588: e8 b7 01 00 00 call 10d744 <_Thread_Set_transient> _Thread_Reset( the_thread, pointer_argument, numeric_argument ); 10d58d: 83 c4 0c add $0xc,%esp 10d590: ff 75 10 pushl 0x10(%ebp) 10d593: ff 75 0c pushl 0xc(%ebp) 10d596: 53 push %ebx 10d597: e8 34 2e 00 00 call 1103d0 <_Thread_Reset> _Thread_Load_environment( the_thread ); 10d59c: 89 1c 24 mov %ebx,(%esp) 10d59f: e8 08 2b 00 00 call 1100ac <_Thread_Load_environment> _Thread_Ready( the_thread ); 10d5a4: 89 1c 24 mov %ebx,(%esp) 10d5a7: e8 84 2d 00 00 call 110330 <_Thread_Ready> _User_extensions_Thread_restart( the_thread ); 10d5ac: 89 1c 24 mov %ebx,(%esp) 10d5af: e8 94 06 00 00 call 10dc48 <_User_extensions_Thread_restart> if ( _Thread_Is_executing ( the_thread ) ) 10d5b4: 83 c4 10 add $0x10,%esp 10d5b7: 3b 1d 7c 17 12 00 cmp 0x12177c,%ebx 10d5bd: 74 09 je 10d5c8 <_Thread_Restart+0x5c> 10d5bf: b0 01 mov $0x1,%al return TRUE; } return FALSE; } 10d5c1: 8b 5d fc mov -0x4(%ebp),%ebx 10d5c4: c9 leave 10d5c5: c3 ret 10d5c6: 66 90 xchg %ax,%ax * 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 10d5c8: 8b 83 ec 00 00 00 mov 0xec(%ebx),%eax 10d5ce: 85 c0 test %eax,%eax 10d5d0: 74 12 je 10d5e4 <_Thread_Restart+0x78> * @return NULL if unsuccessful and a pointer to the block if successful 10d5d2: 83 ec 0c sub $0xc,%esp 10d5d5: 8d 83 ec 00 00 00 lea 0xec(%ebx),%eax 10d5db: 50 push %eax 10d5dc: e8 2d 0a 00 00 call 10e00e <_CPU_Context_restore_fp> 10d5e1: 83 c4 10 add $0x10,%esp */ void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, 10d5e4: 83 ec 0c sub $0xc,%esp 10d5e7: a1 7c 17 12 00 mov 0x12177c,%eax 10d5ec: 05 d4 00 00 00 add $0xd4,%eax 10d5f1: 50 push %eax 10d5f2: e8 06 0a 00 00 call 10dffd <_CPU_Context_restore> 10d5f7: b0 01 mov $0x1,%al <== NOT EXECUTED 10d5f9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10d5fc: eb 80 jmp 10d57e <_Thread_Restart+0x12> <== NOT EXECUTED =============================================================================== 0010e02c <_Thread_Resume>: void _Thread_Resume( Thread_Control *the_thread, bool force ) { 10e02c: 55 push %ebp 10e02d: 89 e5 mov %esp,%ebp 10e02f: 53 push %ebx 10e030: 8b 4d 08 mov 0x8(%ebp),%ecx 10e033: 8a 45 0c mov 0xc(%ebp),%al ISR_Level level; States_Control current_state; _ISR_Disable( level ); 10e036: 9c pushf 10e037: fa cli 10e038: 5b pop %ebx if ( force == TRUE ) 10e039: 84 c0 test %al,%al 10e03b: 74 13 je 10e050 <_Thread_Resume+0x24> <== NEVER TAKEN the_thread->suspend_count = 0; 10e03d: c7 41 70 00 00 00 00 movl $0x0,0x70(%ecx) if ( the_thread->suspend_count > 0 ) { _ISR_Enable( level ); return; } current_state = the_thread->current_state; 10e044: 8b 41 10 mov 0x10(%ecx),%eax if ( current_state & STATES_SUSPENDED ) { 10e047: a8 02 test $0x2,%al 10e049: 75 15 jne 10e060 <_Thread_Resume+0x34> <== ALWAYS TAKEN _Context_Switch_necessary = TRUE; } } } _ISR_Enable( level ); 10e04b: 53 push %ebx 10e04c: 9d popf } 10e04d: 5b pop %ebx 10e04e: c9 leave 10e04f: c3 ret _ISR_Disable( level ); if ( force == TRUE ) the_thread->suspend_count = 0; else the_thread->suspend_count--; 10e050: 8b 41 70 mov 0x70(%ecx),%eax <== NOT EXECUTED 10e053: 48 dec %eax <== NOT EXECUTED 10e054: 89 41 70 mov %eax,0x70(%ecx) <== NOT EXECUTED if ( the_thread->suspend_count > 0 ) { 10e057: 85 c0 test %eax,%eax <== NOT EXECUTED 10e059: 74 e9 je 10e044 <_Thread_Resume+0x18> <== NOT EXECUTED _ISR_Enable( level ); 10e05b: 53 push %ebx <== NOT EXECUTED 10e05c: 9d popf <== NOT EXECUTED } } } _ISR_Enable( level ); } 10e05d: 5b pop %ebx <== NOT EXECUTED 10e05e: c9 leave <== NOT EXECUTED 10e05f: 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( 10e060: 83 e0 fd and $0xfffffffd,%eax return; } current_state = the_thread->current_state; if ( current_state & STATES_SUSPENDED ) { current_state = 10e063: 89 41 10 mov %eax,0x10(%ecx) the_thread->current_state = _States_Clear(STATES_SUSPENDED, current_state); if ( _States_Is_ready( current_state ) ) { 10e066: 85 c0 test %eax,%eax 10e068: 75 e1 jne 10e04b <_Thread_Resume+0x1f> * 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 10e06a: 8b 91 90 00 00 00 mov 0x90(%ecx),%edx 10e070: 66 8b 81 96 00 00 00 mov 0x96(%ecx),%ax 10e077: 66 09 02 or %ax,(%edx) * @return TRUE if successfully able to determine the size, FALSE otherwise 10e07a: 66 a1 30 a7 12 00 mov 0x12a730,%ax 10e080: 0b 81 94 00 00 00 or 0x94(%ecx),%eax 10e086: 66 a3 30 a7 12 00 mov %ax,0x12a730 _Priority_Add_to_bit_map( &the_thread->Priority_map ); _Chain_Append_unprotected(the_thread->ready, &the_thread->Object.Node); 10e08c: 8b 81 8c 00 00 00 mov 0x8c(%ecx),%eax 10e092: 8d 50 04 lea 0x4(%eax),%edx 10e095: 89 11 mov %edx,(%ecx) 10e097: 8b 50 08 mov 0x8(%eax),%edx 10e09a: 89 48 08 mov %ecx,0x8(%eax) 10e09d: 89 0a mov %ecx,(%edx) 10e09f: 89 51 04 mov %edx,0x4(%ecx) _ISR_Flash( level ); 10e0a2: 53 push %ebx 10e0a3: 9d popf 10e0a4: fa cli if ( the_thread->current_priority < _Thread_Heir->current_priority ) { 10e0a5: 8b 51 14 mov 0x14(%ecx),%edx 10e0a8: a1 08 a7 12 00 mov 0x12a708,%eax 10e0ad: 3b 50 14 cmp 0x14(%eax),%edx 10e0b0: 73 99 jae 10e04b <_Thread_Resume+0x1f> _Thread_Heir = the_thread; 10e0b2: 89 0d 08 a7 12 00 mov %ecx,0x12a708 if ( _Thread_Executing->is_preemptible || 10e0b8: a1 3c a7 12 00 mov 0x12a73c,%eax 10e0bd: 80 78 76 00 cmpb $0x0,0x76(%eax) 10e0c1: 74 0d je 10e0d0 <_Thread_Resume+0xa4> the_thread->current_priority == 0 ) _Context_Switch_necessary = TRUE; 10e0c3: c6 05 4c a7 12 00 01 movb $0x1,0x12a74c 10e0ca: e9 7c ff ff ff jmp 10e04b <_Thread_Resume+0x1f> 10e0cf: 90 nop _ISR_Flash( level ); if ( the_thread->current_priority < _Thread_Heir->current_priority ) { _Thread_Heir = the_thread; if ( _Thread_Executing->is_preemptible || 10e0d0: 85 d2 test %edx,%edx 10e0d2: 0f 85 73 ff ff ff jne 10e04b <_Thread_Resume+0x1f> <== ALWAYS TAKEN 10e0d8: eb e9 jmp 10e0c3 <_Thread_Resume+0x97> <== NOT EXECUTED =============================================================================== 0010cba0 <_Thread_Set_state>: void _Thread_Set_state( Thread_Control *the_thread, States_Control state ) { 10cba0: 55 push %ebp 10cba1: 89 e5 mov %esp,%ebp 10cba3: 56 push %esi 10cba4: 53 push %ebx 10cba5: 8b 5d 08 mov 0x8(%ebp),%ebx 10cba8: 8b 4d 0c mov 0xc(%ebp),%ecx ISR_Level level; Chain_Control *ready; ready = the_thread->ready; 10cbab: 8b 93 8c 00 00 00 mov 0x8c(%ebx),%edx _ISR_Disable( level ); 10cbb1: 9c pushf 10cbb2: fa cli 10cbb3: 5e pop %esi if ( !_States_Is_ready( the_thread->current_state ) ) { 10cbb4: 8b 43 10 mov 0x10(%ebx),%eax 10cbb7: 85 c0 test %eax,%eax 10cbb9: 75 2d jne 10cbe8 <_Thread_Set_state+0x48> _States_Set( state, the_thread->current_state ); _ISR_Enable( level ); return; } the_thread->current_state = state; 10cbbb: 89 4b 10 mov %ecx,0x10(%ebx) if ( _Chain_Has_only_one_node( ready ) ) { 10cbbe: 8b 02 mov (%edx),%eax 10cbc0: 3b 42 08 cmp 0x8(%edx),%eax 10cbc3: 74 2f je 10cbf4 <_Thread_Set_state+0x54> 10cbc5: 8b 13 mov (%ebx),%edx 10cbc7: 8b 43 04 mov 0x4(%ebx),%eax 10cbca: 89 42 04 mov %eax,0x4(%edx) 10cbcd: 89 10 mov %edx,(%eax) _Priority_Remove_from_bit_map( &the_thread->Priority_map ); } else _Chain_Extract_unprotected( &the_thread->Object.Node ); _ISR_Flash( level ); 10cbcf: 56 push %esi 10cbd0: 9d popf 10cbd1: fa cli if ( _Thread_Is_heir( the_thread ) ) 10cbd2: 3b 1d e8 e6 11 00 cmp 0x11e6e8,%ebx 10cbd8: 74 62 je 10cc3c <_Thread_Set_state+0x9c> _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) 10cbda: 3b 1d 1c e7 11 00 cmp 0x11e71c,%ebx 10cbe0: 74 4e je 10cc30 <_Thread_Set_state+0x90> _Context_Switch_necessary = TRUE; _ISR_Enable( level ); 10cbe2: 56 push %esi 10cbe3: 9d popf } 10cbe4: 5b pop %ebx 10cbe5: 5e pop %esi 10cbe6: c9 leave 10cbe7: c3 ret Chain_Control *ready; ready = the_thread->ready; _ISR_Disable( level ); if ( !_States_Is_ready( the_thread->current_state ) ) { the_thread->current_state = 10cbe8: 09 c1 or %eax,%ecx 10cbea: 89 4b 10 mov %ecx,0x10(%ebx) _States_Set( state, the_thread->current_state ); _ISR_Enable( level ); 10cbed: 56 push %esi 10cbee: 9d popf if ( _Thread_Is_executing( the_thread ) ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10cbef: 5b pop %ebx 10cbf0: 5e pop %esi 10cbf1: c9 leave 10cbf2: c3 ret 10cbf3: 90 nop 10cbf4: 8d 42 04 lea 0x4(%edx),%eax 10cbf7: 89 02 mov %eax,(%edx) 10cbf9: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) 10cc00: 89 52 08 mov %edx,0x8(%edx) /** * 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 10cc03: 8b 83 90 00 00 00 mov 0x90(%ebx),%eax 10cc09: 66 8b 93 9a 00 00 00 mov 0x9a(%ebx),%dx 10cc10: 66 21 10 and %dx,(%eax) * @param[in] starting_address is the starting address of the user block 10cc13: 66 83 38 00 cmpw $0x0,(%eax) 10cc17: 75 b6 jne 10cbcf <_Thread_Set_state+0x2f> * to be resized 10cc19: 66 a1 10 e7 11 00 mov 0x11e710,%ax 10cc1f: 23 83 98 00 00 00 and 0x98(%ebx),%eax 10cc25: 66 a3 10 e7 11 00 mov %ax,0x11e710 10cc2b: eb a2 jmp 10cbcf <_Thread_Set_state+0x2f> 10cc2d: 8d 76 00 lea 0x0(%esi),%esi if ( _Thread_Is_heir( the_thread ) ) _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) _Context_Switch_necessary = TRUE; 10cc30: c6 05 2c e7 11 00 01 movb $0x1,0x11e72c 10cc37: eb a9 jmp 10cbe2 <_Thread_Set_state+0x42> 10cc39: 8d 76 00 lea 0x0(%esi),%esi void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10cc3c: 66 8b 0d 10 e7 11 00 mov 0x11e710,%cx 10cc43: 31 d2 xor %edx,%edx 10cc45: 89 d0 mov %edx,%eax 10cc47: 66 0f bc c1 bsf %cx,%ax * at @a starting_address to @a the_heap. Any coalescing which is 10cc4b: 0f b7 c0 movzwl %ax,%eax 10cc4e: 66 8b 8c 00 a0 e7 11 mov 0x11e7a0(%eax,%eax,1),%cx 10cc55: 00 10cc56: 66 0f bc d1 bsf %cx,%dx /** * 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. 10cc5a: c1 e0 04 shl $0x4,%eax 10cc5d: 0f b7 d2 movzwl %dx,%edx 10cc60: 01 d0 add %edx,%eax 10cc62: 8d 04 40 lea (%eax,%eax,2),%eax 10cc65: 8b 15 20 e6 11 00 mov 0x11e620,%edx 10cc6b: 8b 04 82 mov (%edx,%eax,4),%eax 10cc6e: a3 e8 e6 11 00 mov %eax,0x11e6e8 10cc73: e9 62 ff ff ff jmp 10cbda <_Thread_Set_state+0x3a> =============================================================================== 0010ccec <_Thread_Stack_Allocate>: size_t _Thread_Stack_Allocate( Thread_Control *the_thread, size_t stack_size ) { 10ccec: 55 push %ebp 10cced: 89 e5 mov %esp,%ebp 10ccef: 53 push %ebx 10ccf0: 83 ec 04 sub $0x4,%esp 10ccf3: a1 10 a1 11 00 mov 0x11a110,%eax 10ccf8: 8b 5d 0c mov 0xc(%ebp),%ebx 10ccfb: 39 c3 cmp %eax,%ebx 10ccfd: 73 02 jae 10cd01 <_Thread_Stack_Allocate+0x15> 10ccff: 89 c3 mov %eax,%ebx * 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 ) { 10cd01: a1 f4 e6 11 00 mov 0x11e6f4,%eax 10cd06: 8b 40 20 mov 0x20(%eax),%eax 10cd09: 85 c0 test %eax,%eax 10cd0b: 74 33 je 10cd40 <_Thread_Stack_Allocate+0x54><== ALWAYS TAKEN stack_addr = (*_Configuration_Table->stack_allocate_hook)( the_stack_size ); 10cd0d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10cd10: 53 push %ebx <== NOT EXECUTED 10cd11: ff d0 call *%eax <== NOT EXECUTED 10cd13: 89 c2 mov %eax,%edx <== NOT EXECUTED 10cd15: 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 ) 10cd18: 85 d2 test %edx,%edx 10cd1a: 74 10 je 10cd2c <_Thread_Stack_Allocate+0x40> the_stack_size = 0; the_thread->Start.stack = stack_addr; 10cd1c: 8b 45 08 mov 0x8(%ebp),%eax 10cd1f: 89 90 d0 00 00 00 mov %edx,0xd0(%eax) return the_stack_size; } 10cd25: 89 d8 mov %ebx,%eax 10cd27: 8b 5d fc mov -0x4(%ebp),%ebx 10cd2a: c9 leave 10cd2b: c3 ret the_stack_size = _Stack_Adjust_size( the_stack_size ); stack_addr = _Workspace_Allocate( the_stack_size ); } if ( !stack_addr ) 10cd2c: 31 db xor %ebx,%ebx the_stack_size = 0; the_thread->Start.stack = stack_addr; 10cd2e: 8b 45 08 mov 0x8(%ebp),%eax 10cd31: 89 90 d0 00 00 00 mov %edx,0xd0(%eax) return the_stack_size; } 10cd37: 89 d8 mov %ebx,%eax 10cd39: 8b 5d fc mov -0x4(%ebp),%ebx 10cd3c: c9 leave 10cd3d: c3 ret 10cd3e: 66 90 xchg %ax,%ax * 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 ); 10cd40: 83 ec 0c sub $0xc,%esp 10cd43: 53 push %ebx 10cd44: e8 d7 06 00 00 call 10d420 <_Workspace_Allocate> 10cd49: 89 c2 mov %eax,%edx 10cd4b: 83 c4 10 add $0x10,%esp 10cd4e: eb c8 jmp 10cd18 <_Thread_Stack_Allocate+0x2c> =============================================================================== 0010cd50 <_Thread_Stack_Free>: */ void _Thread_Stack_Free( Thread_Control *the_thread ) { 10cd50: 55 push %ebp 10cd51: 89 e5 mov %esp,%ebp 10cd53: 8b 55 08 mov 0x8(%ebp),%edx /* * If the API provided the stack space, then don't free it. */ if ( !the_thread->Start.core_allocated_stack ) 10cd56: 80 ba c0 00 00 00 00 cmpb $0x0,0xc0(%edx) 10cd5d: 74 19 je 10cd78 <_Thread_Stack_Free+0x28><== NEVER TAKEN * 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 ) 10cd5f: a1 f4 e6 11 00 mov 0x11e6f4,%eax 10cd64: 8b 48 24 mov 0x24(%eax),%ecx 10cd67: 85 c9 test %ecx,%ecx 10cd69: 74 11 je 10cd7c <_Thread_Stack_Free+0x2c><== ALWAYS TAKEN (*_Configuration_Table->stack_free_hook)( 10cd6b: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax <== NOT EXECUTED 10cd71: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10cd74: 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)( 10cd75: ff e1 jmp *%ecx <== NOT EXECUTED 10cd77: 90 nop <== NOT EXECUTED the_thread->Start.Initial_stack.area ); else _Workspace_Free( the_thread->Start.Initial_stack.area ); } 10cd78: c9 leave <== NOT EXECUTED 10cd79: c3 ret <== NOT EXECUTED 10cd7a: 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 ); 10cd7c: 8b 82 c8 00 00 00 mov 0xc8(%edx),%eax 10cd82: 89 45 08 mov %eax,0x8(%ebp) } 10cd85: c9 leave 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 ); 10cd86: e9 7d 06 00 00 jmp 10d408 <_Workspace_Free> =============================================================================== 0010e3f0 <_Thread_Suspend>: */ void _Thread_Suspend( Thread_Control *the_thread ) { 10e3f0: 55 push %ebp 10e3f1: 89 e5 mov %esp,%ebp 10e3f3: 56 push %esi 10e3f4: 53 push %ebx 10e3f5: 8b 4d 08 mov 0x8(%ebp),%ecx ISR_Level level; Chain_Control *ready; ready = the_thread->ready; 10e3f8: 8b 91 8c 00 00 00 mov 0x8c(%ecx),%edx _ISR_Disable( level ); 10e3fe: 9c pushf 10e3ff: fa cli 10e400: 5b pop %ebx the_thread->suspend_count++; 10e401: ff 41 70 incl 0x70(%ecx) if ( !_States_Is_ready( the_thread->current_state ) ) { 10e404: 8b 41 10 mov 0x10(%ecx),%eax 10e407: 85 c0 test %eax,%eax 10e409: 75 31 jne 10e43c <_Thread_Suspend+0x4c> _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); return; } the_thread->current_state = STATES_SUSPENDED; 10e40b: c7 41 10 02 00 00 00 movl $0x2,0x10(%ecx) if ( _Chain_Has_only_one_node( ready ) ) { 10e412: 8b 02 mov (%edx),%eax 10e414: 3b 42 08 cmp 0x8(%edx),%eax 10e417: 74 2f je 10e448 <_Thread_Suspend+0x58> 10e419: 8b 11 mov (%ecx),%edx 10e41b: 8b 41 04 mov 0x4(%ecx),%eax 10e41e: 89 42 04 mov %eax,0x4(%edx) 10e421: 89 10 mov %edx,(%eax) _Priority_Remove_from_bit_map( &the_thread->Priority_map ); } else _Chain_Extract_unprotected( &the_thread->Object.Node ); _ISR_Flash( level ); 10e423: 53 push %ebx 10e424: 9d popf 10e425: fa cli if ( _Thread_Is_heir( the_thread ) ) 10e426: 3b 0d 08 a7 12 00 cmp 0x12a708,%ecx 10e42c: 74 62 je 10e490 <_Thread_Suspend+0xa0> _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) 10e42e: 3b 0d 3c a7 12 00 cmp 0x12a73c,%ecx 10e434: 74 4e je 10e484 <_Thread_Suspend+0x94> _Context_Switch_necessary = TRUE; _ISR_Enable( level ); 10e436: 53 push %ebx 10e437: 9d popf } 10e438: 5b pop %ebx 10e439: 5e pop %esi 10e43a: c9 leave 10e43b: c3 ret ready = the_thread->ready; _ISR_Disable( level ); the_thread->suspend_count++; if ( !_States_Is_ready( the_thread->current_state ) ) { the_thread->current_state = 10e43c: 83 c8 02 or $0x2,%eax 10e43f: 89 41 10 mov %eax,0x10(%ecx) _States_Set( STATES_SUSPENDED, the_thread->current_state ); _ISR_Enable( level ); 10e442: 53 push %ebx 10e443: 9d popf if ( _Thread_Is_executing( the_thread ) ) _Context_Switch_necessary = TRUE; _ISR_Enable( level ); } 10e444: 5b pop %ebx 10e445: 5e pop %esi 10e446: c9 leave 10e447: c3 ret 10e448: 8d 42 04 lea 0x4(%edx),%eax 10e44b: 89 02 mov %eax,(%edx) 10e44d: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) 10e454: 89 52 08 mov %edx,0x8(%edx) /** * 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 10e457: 8b 81 90 00 00 00 mov 0x90(%ecx),%eax 10e45d: 66 8b 91 9a 00 00 00 mov 0x9a(%ecx),%dx 10e464: 66 21 10 and %dx,(%eax) * @param[in] starting_address is the starting address of the user block 10e467: 66 83 38 00 cmpw $0x0,(%eax) 10e46b: 75 b6 jne 10e423 <_Thread_Suspend+0x33> * to be resized 10e46d: 66 a1 30 a7 12 00 mov 0x12a730,%ax 10e473: 23 81 98 00 00 00 and 0x98(%ecx),%eax 10e479: 66 a3 30 a7 12 00 mov %ax,0x12a730 10e47f: eb a2 jmp 10e423 <_Thread_Suspend+0x33> 10e481: 8d 76 00 lea 0x0(%esi),%esi if ( _Thread_Is_heir( the_thread ) ) _Thread_Calculate_heir(); if ( _Thread_Is_executing( the_thread ) ) _Context_Switch_necessary = TRUE; 10e484: c6 05 4c a7 12 00 01 movb $0x1,0x12a74c 10e48b: eb a9 jmp 10e436 <_Thread_Suspend+0x46> 10e48d: 8d 76 00 lea 0x0(%esi),%esi void *starting_address, size_t size ); /** * This routine returns the block of memory which begins 10e490: 66 8b 35 30 a7 12 00 mov 0x12a730,%si 10e497: 31 d2 xor %edx,%edx 10e499: 89 d0 mov %edx,%eax 10e49b: 66 0f bc c6 bsf %si,%ax * at @a starting_address to @a the_heap. Any coalescing which is 10e49f: 0f b7 c0 movzwl %ax,%eax 10e4a2: 66 8b b4 00 c0 a7 12 mov 0x12a7c0(%eax,%eax,1),%si 10e4a9: 00 10e4aa: 66 0f bc d6 bsf %si,%dx /** * 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. 10e4ae: c1 e0 04 shl $0x4,%eax 10e4b1: 0f b7 d2 movzwl %dx,%edx 10e4b4: 01 d0 add %edx,%eax 10e4b6: 8d 04 40 lea (%eax,%eax,2),%eax 10e4b9: 8b 15 40 a6 12 00 mov 0x12a640,%edx 10e4bf: 8b 04 82 mov (%edx,%eax,4),%eax 10e4c2: a3 08 a7 12 00 mov %eax,0x12a708 10e4c7: e9 62 ff ff ff jmp 10e42e <_Thread_Suspend+0x3e> =============================================================================== 0010ce48 <_Thread_Tickle_timeslice>: * * Output parameters: NONE */ void _Thread_Tickle_timeslice( void ) { 10ce48: 55 push %ebp 10ce49: 89 e5 mov %esp,%ebp 10ce4b: 53 push %ebx 10ce4c: 83 ec 04 sub $0x4,%esp Thread_Control *executing; executing = _Thread_Executing; 10ce4f: 8b 1d 1c e7 11 00 mov 0x11e71c,%ebx /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 10ce55: 80 7b 76 00 cmpb $0x0,0x76(%ebx) 10ce59: 74 19 je 10ce74 <_Thread_Tickle_timeslice+0x2c> return; if ( !_States_Is_ready( executing->current_state ) ) 10ce5b: 8b 43 10 mov 0x10(%ebx),%eax 10ce5e: 85 c0 test %eax,%eax 10ce60: 75 12 jne 10ce74 <_Thread_Tickle_timeslice+0x2c> /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 10ce62: 8b 43 7c mov 0x7c(%ebx),%eax 10ce65: 83 f8 01 cmp $0x1,%eax 10ce68: 72 0a jb 10ce74 <_Thread_Tickle_timeslice+0x2c> 10ce6a: 83 f8 02 cmp $0x2,%eax 10ce6d: 76 29 jbe 10ce98 <_Thread_Tickle_timeslice+0x50><== ALWAYS TAKEN 10ce6f: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 10ce72: 74 08 je 10ce7c <_Thread_Tickle_timeslice+0x34><== NOT EXECUTED case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) (*executing->budget_callout)( executing ); break; } } 10ce74: 8b 5d fc mov -0x4(%ebp),%ebx 10ce77: c9 leave 10ce78: c3 ret 10ce79: 8d 76 00 lea 0x0(%esi),%esi executing->cpu_time_budget = _Thread_Ticks_per_timeslice; } break; case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 10ce7c: 8b 43 78 mov 0x78(%ebx),%eax <== NOT EXECUTED 10ce7f: 48 dec %eax <== NOT EXECUTED 10ce80: 89 43 78 mov %eax,0x78(%ebx) <== NOT EXECUTED 10ce83: 85 c0 test %eax,%eax <== NOT EXECUTED 10ce85: 75 ed jne 10ce74 <_Thread_Tickle_timeslice+0x2c><== NOT EXECUTED (*executing->budget_callout)( executing ); 10ce87: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ce8a: 53 push %ebx <== NOT EXECUTED 10ce8b: ff 93 80 00 00 00 call *0x80(%ebx) <== NOT EXECUTED 10ce91: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ce94: eb de jmp 10ce74 <_Thread_Tickle_timeslice+0x2c><== NOT EXECUTED 10ce96: 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 ) { 10ce98: 8b 43 78 mov 0x78(%ebx),%eax 10ce9b: 48 dec %eax 10ce9c: 89 43 78 mov %eax,0x78(%ebx) 10ce9f: 85 c0 test %eax,%eax 10cea1: 7f d1 jg 10ce74 <_Thread_Tickle_timeslice+0x2c> _Thread_Reset_timeslice(); 10cea3: e8 80 29 00 00 call 10f828 <_Thread_Reset_timeslice> executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10cea8: a1 24 e6 11 00 mov 0x11e624,%eax 10cead: 89 43 78 mov %eax,0x78(%ebx) 10ceb0: eb c2 jmp 10ce74 <_Thread_Tickle_timeslice+0x2c> =============================================================================== 0010ceb4 <_Thread_Yield_processor>: * ready chain * select heir */ void _Thread_Yield_processor( void ) { 10ceb4: 55 push %ebp 10ceb5: 89 e5 mov %esp,%ebp 10ceb7: 56 push %esi 10ceb8: 53 push %ebx ISR_Level level; Thread_Control *executing; Chain_Control *ready; executing = _Thread_Executing; 10ceb9: 8b 0d 1c e7 11 00 mov 0x11e71c,%ecx ready = executing->ready; 10cebf: 8b 99 8c 00 00 00 mov 0x8c(%ecx),%ebx _ISR_Disable( level ); 10cec5: 9c pushf 10cec6: fa cli 10cec7: 5e pop %esi if ( !_Chain_Has_only_one_node( ready ) ) { 10cec8: 8b 03 mov (%ebx),%eax 10ceca: 3b 43 08 cmp 0x8(%ebx),%eax 10cecd: 74 35 je 10cf04 <_Thread_Yield_processor+0x50> 10cecf: 8b 11 mov (%ecx),%edx 10ced1: 8b 41 04 mov 0x4(%ecx),%eax 10ced4: 89 42 04 mov %eax,0x4(%edx) 10ced7: 89 10 mov %edx,(%eax) 10ced9: 8d 43 04 lea 0x4(%ebx),%eax 10cedc: 89 01 mov %eax,(%ecx) 10cede: 8b 43 08 mov 0x8(%ebx),%eax 10cee1: 89 4b 08 mov %ecx,0x8(%ebx) 10cee4: 89 08 mov %ecx,(%eax) 10cee6: 89 41 04 mov %eax,0x4(%ecx) _Chain_Extract_unprotected( &executing->Object.Node ); _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); 10cee9: 56 push %esi 10ceea: 9d popf 10ceeb: fa cli if ( _Thread_Is_heir( executing ) ) 10ceec: 3b 0d e8 e6 11 00 cmp 0x11e6e8,%ecx 10cef2: 74 1c je 10cf10 <_Thread_Yield_processor+0x5c><== ALWAYS TAKEN _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) _Context_Switch_necessary = TRUE; 10cef4: c6 05 2c e7 11 00 01 movb $0x1,0x11e72c _ISR_Enable( level ); 10cefb: 56 push %esi 10cefc: 9d popf } 10cefd: 5b pop %ebx 10cefe: 5e pop %esi 10ceff: c9 leave 10cf00: c3 ret 10cf01: 8d 76 00 lea 0x0(%esi),%esi if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; _Context_Switch_necessary = TRUE; } else if ( !_Thread_Is_heir( executing ) ) 10cf04: 3b 0d e8 e6 11 00 cmp 0x11e6e8,%ecx 10cf0a: 75 e8 jne 10cef4 <_Thread_Yield_processor+0x40><== NEVER TAKEN 10cf0c: eb ed jmp 10cefb <_Thread_Yield_processor+0x47> 10cf0e: 66 90 xchg %ax,%ax _Chain_Append_unprotected( ready, &executing->Object.Node ); _ISR_Flash( level ); if ( _Thread_Is_heir( executing ) ) _Thread_Heir = (Thread_Control *) ready->first; 10cf10: 8b 03 mov (%ebx),%eax 10cf12: a3 e8 e6 11 00 mov %eax,0x11e6e8 10cf17: eb db jmp 10cef4 <_Thread_Yield_processor+0x40> =============================================================================== 0010f58c <_Thread_queue_Dequeue_fifo>: */ Thread_Control *_Thread_queue_Dequeue_fifo( Thread_queue_Control *the_thread_queue ) { 10f58c: 55 push %ebp 10f58d: 89 e5 mov %esp,%ebp 10f58f: 56 push %esi 10f590: 53 push %ebx 10f591: 8b 4d 08 mov 0x8(%ebp),%ecx ISR_Level level; Thread_Control *the_thread; _ISR_Disable( level ); 10f594: 9c pushf 10f595: fa cli 10f596: 5e pop %esi * 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( 10f597: 8b 11 mov (%ecx),%edx if ( !_Chain_Is_empty( &the_thread_queue->Queues.Fifo ) ) { 10f599: 8d 41 04 lea 0x4(%ecx),%eax 10f59c: 39 c2 cmp %eax,%edx 10f59e: 74 62 je 10f602 <_Thread_queue_Dequeue_fifo+0x76> 10f5a0: 8b 02 mov (%edx),%eax 10f5a2: 89 01 mov %eax,(%ecx) 10f5a4: 89 48 04 mov %ecx,0x4(%eax) the_thread = (Thread_Control *) 10f5a7: 89 d3 mov %edx,%ebx _Chain_Get_first_unprotected( &the_thread_queue->Queues.Fifo ); the_thread->Wait.queue = NULL; 10f5a9: c7 42 44 00 00 00 00 movl $0x0,0x44(%edx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10f5b0: 83 7a 50 02 cmpl $0x2,0x50(%edx) 10f5b4: 74 1e je 10f5d4 <_Thread_queue_Dequeue_fifo+0x48> _ISR_Enable( level ); 10f5b6: 56 push %esi 10f5b7: 9d popf void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10f5b8: 83 ec 08 sub $0x8,%esp 10f5bb: 68 f8 ff 03 10 push $0x1003fff8 10f5c0: 52 push %edx 10f5c1: e8 7e c9 ff ff call 10bf44 <_Thread_Clear_state> 10f5c6: 83 c4 10 add $0x10,%esp return the_thread; } _ISR_Enable( level ); return NULL; } 10f5c9: 89 d8 mov %ebx,%eax 10f5cb: 8d 65 f8 lea -0x8(%ebp),%esp 10f5ce: 5b pop %ebx 10f5cf: 5e pop %esi 10f5d0: c9 leave 10f5d1: c3 ret 10f5d2: 66 90 xchg %ax,%ax * 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 */ 10f5d4: c7 42 50 03 00 00 00 movl $0x3,0x50(%edx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10f5db: 56 push %esi 10f5dc: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 10f5dd: 83 ec 0c sub $0xc,%esp 10f5e0: 8d 42 48 lea 0x48(%edx),%eax 10f5e3: 50 push %eax 10f5e4: e8 43 dd ff ff call 10d32c <_Watchdog_Remove> void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10f5e9: 58 pop %eax 10f5ea: 5a pop %edx 10f5eb: 68 f8 ff 03 10 push $0x1003fff8 10f5f0: 53 push %ebx 10f5f1: e8 4e c9 ff ff call 10bf44 <_Thread_Clear_state> 10f5f6: 83 c4 10 add $0x10,%esp return the_thread; } _ISR_Enable( level ); return NULL; } 10f5f9: 89 d8 mov %ebx,%eax 10f5fb: 8d 65 f8 lea -0x8(%ebp),%esp 10f5fe: 5b pop %ebx 10f5ff: 5e pop %esi 10f600: c9 leave 10f601: c3 ret #endif return the_thread; } _ISR_Enable( level ); 10f602: 56 push %esi 10f603: 9d popf 10f604: 31 db xor %ebx,%ebx 10f606: eb c1 jmp 10f5c9 <_Thread_queue_Dequeue_fifo+0x3d> =============================================================================== 0010c6c0 <_Thread_queue_Dequeue_priority>: */ Thread_Control *_Thread_queue_Dequeue_priority( Thread_queue_Control *the_thread_queue ) { 10c6c0: 55 push %ebp 10c6c1: 89 e5 mov %esp,%ebp 10c6c3: 57 push %edi 10c6c4: 56 push %esi 10c6c5: 53 push %ebx 10c6c6: 83 ec 0c sub $0xc,%esp 10c6c9: 8b 75 08 mov 0x8(%ebp),%esi Chain_Node *new_second_node; Chain_Node *last_node; Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); 10c6cc: 9c pushf 10c6cd: fa cli 10c6ce: 5f pop %edi 10c6cf: 31 d2 xor %edx,%edx 10c6d1: 31 c9 xor %ecx,%ecx * 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( 10c6d3: 8b 1c 0e mov (%esi,%ecx,1),%ebx for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) { 10c6d6: 8d 04 52 lea (%edx,%edx,2),%eax 10c6d9: 8d 44 86 04 lea 0x4(%esi,%eax,4),%eax 10c6dd: 39 c3 cmp %eax,%ebx 10c6df: 75 1f jne 10c700 <_Thread_queue_Dequeue_priority+0x40> Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 10c6e1: 42 inc %edx 10c6e2: 83 c1 0c add $0xc,%ecx Chain_Node *next_node; Chain_Node *previous_node; _ISR_Disable( level ); for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 10c6e5: 83 fa 04 cmp $0x4,%edx 10c6e8: 75 e9 jne 10c6d3 <_Thread_queue_Dequeue_priority+0x13> } /* * We did not find a thread to unblock. */ _ISR_Enable( level ); 10c6ea: 57 push %edi 10c6eb: 9d popf 10c6ec: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp) #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 10c6f3: 8b 45 e8 mov -0x18(%ebp),%eax 10c6f6: 8d 65 f4 lea -0xc(%ebp),%esp 10c6f9: 5b pop %ebx 10c6fa: 5e pop %esi 10c6fb: 5f pop %edi 10c6fc: c9 leave 10c6fd: c3 ret 10c6fe: 66 90 xchg %ax,%ax _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 *) 10c700: 89 5d e8 mov %ebx,-0x18(%ebp) */ _ISR_Enable( level ); return NULL; dequeue: the_thread->Wait.queue = NULL; 10c703: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) new_first_node = the_thread->Wait.Block2n.first; 10c70a: 8b 53 38 mov 0x38(%ebx),%edx new_first_thread = (Thread_Control *) new_first_node; next_node = the_thread->Object.Node.next; 10c70d: 8b 33 mov (%ebx),%esi previous_node = the_thread->Object.Node.previous; 10c70f: 8b 4b 04 mov 0x4(%ebx),%ecx if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10c712: 8d 43 3c lea 0x3c(%ebx),%eax 10c715: 39 c2 cmp %eax,%edx 10c717: 0f 84 85 00 00 00 je 10c7a2 <_Thread_queue_Dequeue_priority+0xe2> last_node = the_thread->Wait.Block2n.last; 10c71d: 8b 43 40 mov 0x40(%ebx),%eax 10c720: 89 45 f0 mov %eax,-0x10(%ebp) new_second_node = new_first_node->next; 10c723: 8b 02 mov (%edx),%eax 10c725: 89 45 ec mov %eax,-0x14(%ebp) previous_node->next = new_first_node; 10c728: 89 11 mov %edx,(%ecx) next_node->previous = new_first_node; 10c72a: 89 56 04 mov %edx,0x4(%esi) new_first_node->next = next_node; 10c72d: 89 32 mov %esi,(%edx) new_first_node->previous = previous_node; 10c72f: 89 4a 04 mov %ecx,0x4(%edx) if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10c732: 8b 43 38 mov 0x38(%ebx),%eax 10c735: 3b 43 40 cmp 0x40(%ebx),%eax 10c738: 74 1a je 10c754 <_Thread_queue_Dequeue_priority+0x94> /* > two threads on 2-n */ new_second_node->previous = 10c73a: 8d 42 38 lea 0x38(%edx),%eax 10c73d: 8b 4d ec mov -0x14(%ebp),%ecx 10c740: 89 41 04 mov %eax,0x4(%ecx) _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 10c743: 89 4a 38 mov %ecx,0x38(%edx) new_first_thread->Wait.Block2n.last = last_node; 10c746: 8b 45 f0 mov -0x10(%ebp),%eax 10c749: 89 42 40 mov %eax,0x40(%edx) last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10c74c: 8d 42 3c lea 0x3c(%edx),%eax 10c74f: 8b 55 f0 mov -0x10(%ebp),%edx 10c752: 89 02 mov %eax,(%edx) } else { previous_node->next = next_node; next_node->previous = previous_node; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10c754: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 10c758: 74 1e je 10c778 <_Thread_queue_Dequeue_priority+0xb8> _ISR_Enable( level ); 10c75a: 57 push %edi 10c75b: 9d popf void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10c75c: 83 ec 08 sub $0x8,%esp 10c75f: 68 f8 ff 03 10 push $0x1003fff8 10c764: 53 push %ebx 10c765: e8 da f7 ff ff call 10bf44 <_Thread_Clear_state> 10c76a: 83 c4 10 add $0x10,%esp #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif return( the_thread ); } 10c76d: 8b 45 e8 mov -0x18(%ebp),%eax 10c770: 8d 65 f4 lea -0xc(%ebp),%esp 10c773: 5b pop %ebx 10c774: 5e pop %esi 10c775: 5f pop %edi 10c776: c9 leave 10c777: c3 ret * 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 */ 10c778: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); _Thread_Unblock( the_thread ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 10c77f: 57 push %edi 10c780: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 10c781: 83 ec 0c sub $0xc,%esp 10c784: 8d 43 48 lea 0x48(%ebx),%eax 10c787: 50 push %eax 10c788: e8 9f 0b 00 00 call 10d32c <_Watchdog_Remove> void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10c78d: 58 pop %eax 10c78e: 5a pop %edx 10c78f: 68 f8 ff 03 10 push $0x1003fff8 10c794: 53 push %ebx 10c795: e8 aa f7 ff ff call 10bf44 <_Thread_Clear_state> 10c79a: 83 c4 10 add $0x10,%esp 10c79d: e9 51 ff ff ff jmp 10c6f3 <_Thread_queue_Dequeue_priority+0x33> new_first_thread->Wait.Block2n.last = last_node; last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); } } else { previous_node->next = next_node; 10c7a2: 89 31 mov %esi,(%ecx) next_node->previous = previous_node; 10c7a4: 89 4e 04 mov %ecx,0x4(%esi) 10c7a7: eb ab jmp 10c754 <_Thread_queue_Dequeue_priority+0x94> =============================================================================== 0010c844 <_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 ) { 10c844: 55 push %ebp 10c845: 89 e5 mov %esp,%ebp 10c847: 57 push %edi 10c848: 56 push %esi 10c849: 53 push %ebx 10c84a: 83 ec 0c sub $0xc,%esp 10c84d: 8b 45 0c mov 0xc(%ebp),%eax 10c850: 83 c0 3c add $0x3c,%eax 10c853: 8b 55 0c mov 0xc(%ebp),%edx 10c856: 89 42 38 mov %eax,0x38(%edx) 10c859: c7 42 3c 00 00 00 00 movl $0x0,0x3c(%edx) 10c860: 89 d0 mov %edx,%eax 10c862: 83 c0 38 add $0x38,%eax 10c865: 89 42 40 mov %eax,0x40(%edx) Priority_Control priority; States_Control block_state; _Chain_Initialize_empty( &the_thread->Wait.Block2n ); priority = the_thread->current_priority; 10c868: 8b 5a 14 mov 0x14(%edx),%ebx 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. 10c86b: 89 d8 mov %ebx,%eax 10c86d: c1 e8 06 shr $0x6,%eax header_index = _Thread_queue_Header_number( priority ); header = &the_thread_queue->Queues.Priority[ header_index ]; block_state = the_thread_queue->state; 10c870: 8b 4d 08 mov 0x8(%ebp),%ecx 10c873: 8b 49 38 mov 0x38(%ecx),%ecx 10c876: 89 4d f0 mov %ecx,-0x10(%ebp) if ( _Thread_queue_Is_reverse_search( priority ) ) 10c879: f6 c3 20 test $0x20,%bl 10c87c: 75 66 jne 10c8e4 <_Thread_queue_Enqueue_priority+0xa0> * @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 10c87e: 8d 04 40 lea (%eax,%eax,2),%eax 10c881: c1 e0 02 shl $0x2,%eax 10c884: 8b 55 08 mov 0x8(%ebp),%edx 10c887: 8d 7c 02 04 lea 0x4(%edx,%eax,1),%edi goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->first; 10c88b: 89 45 e8 mov %eax,-0x18(%ebp) if ( _Thread_queue_Is_reverse_search( priority ) ) goto restart_reverse_search; restart_forward_search: search_priority = PRIORITY_MINIMUM - 1; _ISR_Disable( level ); 10c88e: 9c pushf 10c88f: fa cli 10c890: 5e pop %esi search_thread = (Thread_Control *) header->first; 10c891: 8b 45 e8 mov -0x18(%ebp),%eax 10c894: 8b 4d 08 mov 0x8(%ebp),%ecx 10c897: 8b 14 08 mov (%eax,%ecx,1),%edx while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) { 10c89a: 39 fa cmp %edi,%edx 10c89c: 75 1b jne 10c8b9 <_Thread_queue_Enqueue_priority+0x75> 10c89e: e9 1a 01 00 00 jmp 10c9bd <_Thread_queue_Enqueue_priority+0x179> 10c8a3: 90 nop break; search_priority = search_thread->current_priority; if ( priority <= search_priority ) break; #endif _ISR_Flash( level ); 10c8a4: 56 push %esi 10c8a5: 9d popf 10c8a6: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c8a7: 8b 45 f0 mov -0x10(%ebp),%eax 10c8aa: 85 42 10 test %eax,0x10(%edx) 10c8ad: 0f 84 ad 00 00 00 je 10c960 <_Thread_queue_Enqueue_priority+0x11c><== NEVER TAKEN _ISR_Enable( level ); goto restart_forward_search; } search_thread = 10c8b3: 8b 12 mov (%edx),%edx 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 ) ) { 10c8b5: 39 fa cmp %edi,%edx 10c8b7: 74 07 je 10c8c0 <_Thread_queue_Enqueue_priority+0x7c> search_priority = search_thread->current_priority; 10c8b9: 8b 4a 14 mov 0x14(%edx),%ecx if ( priority <= search_priority ) 10c8bc: 39 cb cmp %ecx,%ebx 10c8be: 77 e4 ja 10c8a4 <_Thread_queue_Enqueue_priority+0x60> 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 ) ) { 10c8c0: 89 d7 mov %edx,%edi } search_thread = (Thread_Control *)search_thread->Object.Node.next; } if ( the_thread_queue->sync_state != 10c8c2: 8b 45 08 mov 0x8(%ebp),%eax 10c8c5: 83 78 30 01 cmpl $0x1,0x30(%eax) 10c8c9: 0f 84 99 00 00 00 je 10c968 <_Thread_queue_Enqueue_priority+0x124><== ALWAYS TAKEN * 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; 10c8cf: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10c8d2: 89 30 mov %esi,(%eax) <== NOT EXECUTED return the_thread_queue->sync_state; 10c8d4: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10c8d7: 8b 42 30 mov 0x30(%edx),%eax <== NOT EXECUTED } 10c8da: 83 c4 0c add $0xc,%esp 10c8dd: 5b pop %ebx 10c8de: 5e pop %esi 10c8df: 5f pop %edi 10c8e0: c9 leave 10c8e1: c3 ret 10c8e2: 66 90 xchg %ax,%ax 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; 10c8e4: 8d 04 40 lea (%eax,%eax,2),%eax 10c8e7: 8b 55 08 mov 0x8(%ebp),%edx 10c8ea: 8d 0c 82 lea (%edx,%eax,4),%ecx restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; _ISR_Disable( level ); search_thread = (Thread_Control *) header->last; 10c8ed: 8d 79 08 lea 0x8(%ecx),%edi 10c8f0: 89 7d ec mov %edi,-0x14(%ebp) the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED; restart_reverse_search: search_priority = PRIORITY_MAXIMUM + 1; 10c8f3: 0f b6 05 14 a1 11 00 movzbl 0x11a114,%eax 10c8fa: 40 inc %eax _ISR_Disable( level ); 10c8fb: 9c pushf 10c8fc: fa cli 10c8fd: 5e pop %esi search_thread = (Thread_Control *) header->last; 10c8fe: 8b 7d ec mov -0x14(%ebp),%edi 10c901: 8b 17 mov (%edi),%edx while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) { 10c903: 39 d1 cmp %edx,%ecx 10c905: 75 17 jne 10c91e <_Thread_queue_Enqueue_priority+0xda> 10c907: eb 1c jmp 10c925 <_Thread_queue_Enqueue_priority+0xe1> 10c909: 8d 76 00 lea 0x0(%esi),%esi break; search_priority = search_thread->current_priority; if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); 10c90c: 56 push %esi 10c90d: 9d popf 10c90e: fa cli if ( !_States_Are_set( search_thread->current_state, block_state) ) { 10c90f: 8b 7d f0 mov -0x10(%ebp),%edi 10c912: 85 7a 10 test %edi,0x10(%edx) 10c915: 74 45 je 10c95c <_Thread_queue_Enqueue_priority+0x118><== NEVER TAKEN _ISR_Enable( level ); goto restart_reverse_search; } search_thread = (Thread_Control *) 10c917: 8b 52 04 mov 0x4(%edx),%edx 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 ) ) { 10c91a: 39 ca cmp %ecx,%edx 10c91c: 74 07 je 10c925 <_Thread_queue_Enqueue_priority+0xe1> search_priority = search_thread->current_priority; 10c91e: 8b 42 14 mov 0x14(%edx),%eax if ( priority >= search_priority ) 10c921: 39 c3 cmp %eax,%ebx 10c923: 72 e7 jb 10c90c <_Thread_queue_Enqueue_priority+0xc8> 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 ) ) { 10c925: 89 d7 mov %edx,%edi } search_thread = (Thread_Control *) search_thread->Object.Node.previous; } if ( the_thread_queue->sync_state != 10c927: 8b 4d 08 mov 0x8(%ebp),%ecx 10c92a: 83 79 30 01 cmpl $0x1,0x30(%ecx) 10c92e: 75 9f jne 10c8cf <_Thread_queue_Enqueue_priority+0x8b><== NEVER TAKEN THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED ) goto synchronize; the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED; 10c930: c7 41 30 00 00 00 00 movl $0x0,0x30(%ecx) if ( priority == search_priority ) 10c937: 39 c3 cmp %eax,%ebx 10c939: 74 5d je 10c998 <_Thread_queue_Enqueue_priority+0x154> goto equal_priority; search_node = (Chain_Node *) search_thread; next_node = search_node->next; 10c93b: 8b 02 mov (%edx),%eax the_node = (Chain_Node *) the_thread; the_node->next = next_node; 10c93d: 8b 7d 0c mov 0xc(%ebp),%edi 10c940: 89 07 mov %eax,(%edi) the_node->previous = search_node; 10c942: 89 57 04 mov %edx,0x4(%edi) search_node->next = the_node; 10c945: 89 3a mov %edi,(%edx) next_node->previous = the_node; 10c947: 89 78 04 mov %edi,0x4(%eax) the_thread->Wait.queue = the_thread_queue; 10c94a: 89 4f 44 mov %ecx,0x44(%edi) _ISR_Enable( level ); 10c94d: 56 push %esi 10c94e: 9d popf 10c94f: b8 01 00 00 00 mov $0x1,%eax * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10c954: 83 c4 0c add $0xc,%esp 10c957: 5b pop %ebx 10c958: 5e pop %esi 10c959: 5f pop %edi 10c95a: c9 leave 10c95b: c3 ret if ( priority >= search_priority ) break; #endif _ISR_Flash( level ); if ( !_States_Are_set( search_thread->current_state, block_state) ) { _ISR_Enable( level ); 10c95c: 56 push %esi <== NOT EXECUTED 10c95d: 9d popf <== NOT EXECUTED 10c95e: eb 93 jmp 10c8f3 <_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 ); 10c960: 56 push %esi <== NOT EXECUTED 10c961: 9d popf <== NOT EXECUTED 10c962: e9 27 ff ff ff jmp 10c88e <_Thread_queue_Enqueue_priority+0x4a><== NOT EXECUTED 10c967: 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; 10c968: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) if ( priority == search_priority ) 10c96f: 39 cb cmp %ecx,%ebx 10c971: 74 25 je 10c998 <_Thread_queue_Enqueue_priority+0x154> goto equal_priority; search_node = (Chain_Node *) search_thread; previous_node = search_node->previous; 10c973: 8b 42 04 mov 0x4(%edx),%eax the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c976: 8b 4d 0c mov 0xc(%ebp),%ecx 10c979: 89 11 mov %edx,(%ecx) the_node->previous = previous_node; 10c97b: 89 41 04 mov %eax,0x4(%ecx) previous_node->next = the_node; 10c97e: 89 08 mov %ecx,(%eax) search_node->previous = the_node; 10c980: 89 4a 04 mov %ecx,0x4(%edx) the_thread->Wait.queue = the_thread_queue; 10c983: 8b 7d 08 mov 0x8(%ebp),%edi 10c986: 89 79 44 mov %edi,0x44(%ecx) _ISR_Enable( level ); 10c989: 56 push %esi 10c98a: 9d popf 10c98b: b8 01 00 00 00 mov $0x1,%eax * * WARNING! Returning with interrupts disabled! */ *level_p = level; return the_thread_queue->sync_state; } 10c990: 83 c4 0c add $0xc,%esp 10c993: 5b pop %ebx 10c994: 5e pop %esi 10c995: 5f pop %edi 10c996: c9 leave 10c997: c3 ret 10c998: 8d 47 3c lea 0x3c(%edi),%eax _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; 10c99b: 8b 50 04 mov 0x4(%eax),%edx the_node = (Chain_Node *) the_thread; the_node->next = search_node; 10c99e: 8b 4d 0c mov 0xc(%ebp),%ecx 10c9a1: 89 01 mov %eax,(%ecx) the_node->previous = previous_node; 10c9a3: 89 51 04 mov %edx,0x4(%ecx) previous_node->next = the_node; 10c9a6: 89 0a mov %ecx,(%edx) search_node->previous = the_node; 10c9a8: 89 48 04 mov %ecx,0x4(%eax) the_thread->Wait.queue = the_thread_queue; 10c9ab: 8b 7d 08 mov 0x8(%ebp),%edi 10c9ae: 89 79 44 mov %edi,0x44(%ecx) _ISR_Enable( level ); 10c9b1: 56 push %esi 10c9b2: 9d popf 10c9b3: b8 01 00 00 00 mov $0x1,%eax 10c9b8: e9 1d ff ff ff jmp 10c8da <_Thread_queue_Enqueue_priority+0x96> 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 ) ) { 10c9bd: b9 ff ff ff ff mov $0xffffffff,%ecx 10c9c2: e9 fb fe ff ff jmp 10c8c2 <_Thread_queue_Enqueue_priority+0x7e> =============================================================================== 0010f64c <_Thread_queue_Extract>: void _Thread_queue_Extract( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10f64c: 55 push %ebp 10f64d: 89 e5 mov %esp,%ebp 10f64f: 83 ec 08 sub $0x8,%esp 10f652: 8b 45 08 mov 0x8(%ebp),%eax 10f655: 8b 55 0c mov 0xc(%ebp),%edx /* * 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 ) 10f658: 83 78 34 01 cmpl $0x1,0x34(%eax) 10f65c: 74 0e je 10f66c <_Thread_queue_Extract+0x20> _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 ); 10f65e: 89 55 0c mov %edx,0xc(%ebp) 10f661: 89 45 08 mov %eax,0x8(%ebp) } 10f664: c9 leave * 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 ); 10f665: e9 ce 0a 00 00 jmp 110138 <_Thread_queue_Extract_fifo> 10f66a: 66 90 xchg %ax,%ax /* * 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 ); 10f66c: 51 push %ecx 10f66d: 6a 00 push $0x0 10f66f: 52 push %edx 10f670: 50 push %eax 10f671: e8 06 00 00 00 call 10f67c <_Thread_queue_Extract_priority_helper> 10f676: 83 c4 10 add $0x10,%esp else /* must be THREAD_QUEUE_DISCIPLINE_FIFO */ _Thread_queue_Extract_fifo( the_thread_queue, the_thread ); } 10f679: c9 leave 10f67a: c3 ret =============================================================================== 00110138 <_Thread_queue_Extract_fifo>: void _Thread_queue_Extract_fifo( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 110138: 55 push %ebp 110139: 89 e5 mov %esp,%ebp 11013b: 53 push %ebx 11013c: 83 ec 04 sub $0x4,%esp 11013f: 8b 5d 0c mov 0xc(%ebp),%ebx ISR_Level level; _ISR_Disable( level ); 110142: 9c pushf 110143: fa cli 110144: 59 pop %ecx if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 110145: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) 11014c: 74 2e je 11017c <_Thread_queue_Extract_fifo+0x44><== NEVER TAKEN 11014e: 8b 13 mov (%ebx),%edx 110150: 8b 43 04 mov 0x4(%ebx),%eax 110153: 89 42 04 mov %eax,0x4(%edx) 110156: 89 10 mov %edx,(%eax) return; } _Chain_Extract_unprotected( &the_thread->Object.Node ); the_thread->Wait.queue = NULL; 110158: c7 43 44 00 00 00 00 movl $0x0,0x44(%ebx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 11015f: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 110163: 74 1f je 110184 <_Thread_queue_Extract_fifo+0x4c> _ISR_Enable( level ); 110165: 51 push %ecx 110166: 9d popf void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 110167: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 11016e: 89 5d 08 mov %ebx,0x8(%ebp) #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 110171: 8b 5d fc mov -0x4(%ebp),%ebx 110174: c9 leave 110175: e9 ca bd ff ff jmp 10bf44 <_Thread_Clear_state> 11017a: 66 90 xchg %ax,%ax ISR_Level level; _ISR_Disable( level ); if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { _ISR_Enable( level ); 11017c: 51 push %ecx <== NOT EXECUTED 11017d: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 11017e: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 110181: c9 leave <== NOT EXECUTED 110182: c3 ret <== NOT EXECUTED 110183: 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 */ 110184: c7 43 50 03 00 00 00 movl $0x3,0x50(%ebx) if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { _ISR_Enable( level ); } else { _Watchdog_Deactivate( &the_thread->Timer ); _ISR_Enable( level ); 11018b: 51 push %ecx 11018c: 9d popf (void) _Watchdog_Remove( &the_thread->Timer ); 11018d: 83 ec 0c sub $0xc,%esp 110190: 8d 43 48 lea 0x48(%ebx),%eax 110193: 50 push %eax 110194: e8 93 d1 ff ff call 10d32c <_Watchdog_Remove> 110199: 83 c4 10 add $0x10,%esp 11019c: eb c9 jmp 110167 <_Thread_queue_Extract_fifo+0x2f> =============================================================================== 0010f67c <_Thread_queue_Extract_priority_helper>: void _Thread_queue_Extract_priority_helper( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread, bool requeuing ) { 10f67c: 55 push %ebp 10f67d: 89 e5 mov %esp,%ebp 10f67f: 57 push %edi 10f680: 56 push %esi 10f681: 53 push %ebx 10f682: 83 ec 0c sub $0xc,%esp 10f685: 8b 5d 0c mov 0xc(%ebp),%ebx 10f688: 8a 45 10 mov 0x10(%ebp),%al 10f68b: 88 45 eb mov %al,-0x15(%ebp) Chain_Node *new_first_node; Chain_Node *new_second_node; Chain_Node *last_node; the_node = (Chain_Node *) the_thread; _ISR_Disable( level ); 10f68e: 9c pushf 10f68f: fa cli 10f690: 8f 45 ec popl -0x14(%ebp) if ( !_States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10f693: f7 43 10 e0 be 03 00 testl $0x3bee0,0x10(%ebx) 10f69a: 74 68 je 10f704 <_Thread_queue_Extract_priority_helper+0x88><== NEVER TAKEN /* * The thread was actually waiting on a thread queue so let's remove it. */ next_node = the_node->next; 10f69c: 8b 33 mov (%ebx),%esi previous_node = the_node->previous; 10f69e: 8b 4b 04 mov 0x4(%ebx),%ecx * 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( 10f6a1: 8b 53 38 mov 0x38(%ebx),%edx if ( !_Chain_Is_empty( &the_thread->Wait.Block2n ) ) { 10f6a4: 8d 43 3c lea 0x3c(%ebx),%eax 10f6a7: 39 c2 cmp %eax,%edx 10f6a9: 74 71 je 10f71c <_Thread_queue_Extract_priority_helper+0xa0> new_first_node = the_thread->Wait.Block2n.first; new_first_thread = (Thread_Control *) new_first_node; last_node = the_thread->Wait.Block2n.last; 10f6ab: 8b 43 40 mov 0x40(%ebx),%eax 10f6ae: 89 45 f0 mov %eax,-0x10(%ebp) new_second_node = new_first_node->next; 10f6b1: 8b 3a mov (%edx),%edi previous_node->next = new_first_node; 10f6b3: 89 11 mov %edx,(%ecx) next_node->previous = new_first_node; 10f6b5: 89 56 04 mov %edx,0x4(%esi) new_first_node->next = next_node; 10f6b8: 89 32 mov %esi,(%edx) new_first_node->previous = previous_node; 10f6ba: 89 4a 04 mov %ecx,0x4(%edx) if ( !_Chain_Has_only_one_node( &the_thread->Wait.Block2n ) ) { 10f6bd: 8b 43 38 mov 0x38(%ebx),%eax 10f6c0: 3b 43 40 cmp 0x40(%ebx),%eax 10f6c3: 74 17 je 10f6dc <_Thread_queue_Extract_priority_helper+0x60> /* > two threads on 2-n */ new_second_node->previous = 10f6c5: 8d 42 38 lea 0x38(%edx),%eax 10f6c8: 89 47 04 mov %eax,0x4(%edi) _Chain_Head( &new_first_thread->Wait.Block2n ); new_first_thread->Wait.Block2n.first = new_second_node; 10f6cb: 89 7a 38 mov %edi,0x38(%edx) new_first_thread->Wait.Block2n.last = last_node; 10f6ce: 8b 45 f0 mov -0x10(%ebp),%eax 10f6d1: 89 42 40 mov %eax,0x40(%edx) last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); 10f6d4: 8d 42 3c lea 0x3c(%edx),%eax 10f6d7: 8b 55 f0 mov -0x10(%ebp),%edx 10f6da: 89 02 mov %eax,(%edx) /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { 10f6dc: 80 7d eb 00 cmpb $0x0,-0x15(%ebp) 10f6e0: 75 2e jne 10f710 <_Thread_queue_Extract_priority_helper+0x94> _ISR_Enable( level ); return; } if ( !_Watchdog_Is_active( &the_thread->Timer ) ) { 10f6e2: 83 7b 50 02 cmpl $0x2,0x50(%ebx) 10f6e6: 74 3c je 10f724 <_Thread_queue_Extract_priority_helper+0xa8><== NEVER TAKEN _ISR_Enable( level ); 10f6e8: ff 75 ec pushl -0x14(%ebp) 10f6eb: 9d popf void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); /** 10f6ec: c7 45 0c f8 ff 03 10 movl $0x1003fff8,0xc(%ebp) 10f6f3: 89 5d 08 mov %ebx,0x8(%ebp) #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10f6f6: 8d 65 f4 lea -0xc(%ebp),%esp 10f6f9: 5b pop %ebx 10f6fa: 5e pop %esi 10f6fb: 5f pop %edi 10f6fc: c9 leave 10f6fd: e9 42 c8 ff ff jmp 10bf44 <_Thread_Clear_state> 10f702: 66 90 xchg %ax,%ax 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 ); 10f704: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10f707: 9d popf <== NOT EXECUTED #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10f708: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10f70b: 5b pop %ebx <== NOT EXECUTED 10f70c: 5e pop %esi <== NOT EXECUTED 10f70d: 5f pop %edi <== NOT EXECUTED 10f70e: c9 leave <== NOT EXECUTED 10f70f: c3 ret <== NOT EXECUTED /* * If we are not supposed to touch timers or the thread's state, return. */ if ( requeuing ) { _ISR_Enable( level ); 10f710: ff 75 ec pushl -0x14(%ebp) 10f713: 9d popf #if defined(RTEMS_MULTIPROCESSING) if ( !_Objects_Is_local_id( the_thread->Object.id ) ) _Thread_MP_Free_proxy( the_thread ); #endif } 10f714: 8d 65 f4 lea -0xc(%ebp),%esp 10f717: 5b pop %ebx 10f718: 5e pop %esi 10f719: 5f pop %edi 10f71a: c9 leave 10f71b: c3 ret new_first_thread->Wait.Block2n.last = last_node; last_node->next = _Chain_Tail( &new_first_thread->Wait.Block2n ); } } else { previous_node->next = next_node; 10f71c: 89 31 mov %esi,(%ecx) next_node->previous = previous_node; 10f71e: 89 4e 04 mov %ecx,0x4(%esi) 10f721: eb b9 jmp 10f6dc <_Thread_queue_Extract_priority_helper+0x60> 10f723: 90 nop * 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 */ 10f724: 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 ); 10f72b: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 10f72e: 9d popf <== NOT EXECUTED (void) _Watchdog_Remove( &the_thread->Timer ); 10f72f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10f732: 8d 43 48 lea 0x48(%ebx),%eax <== NOT EXECUTED 10f735: 50 push %eax <== NOT EXECUTED 10f736: e8 f1 db ff ff call 10d32c <_Watchdog_Remove> <== NOT EXECUTED 10f73b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f73e: eb ac jmp 10f6ec <_Thread_queue_Extract_priority_helper+0x70><== NOT EXECUTED =============================================================================== 0010c9c8 <_Thread_queue_Extract_with_proxy>: */ bool _Thread_queue_Extract_with_proxy( Thread_Control *the_thread ) { 10c9c8: 55 push %ebp 10c9c9: 89 e5 mov %esp,%ebp 10c9cb: 83 ec 08 sub $0x8,%esp 10c9ce: 8b 45 08 mov 0x8(%ebp),%eax States_Control state; state = the_thread->current_state; if ( _States_Is_waiting_on_thread_queue( state ) ) { 10c9d1: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax) 10c9d8: 75 06 jne 10c9e0 <_Thread_queue_Extract_with_proxy+0x18> 10c9da: 31 c0 xor %eax,%eax _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); return TRUE; } return FALSE; } 10c9dc: c9 leave 10c9dd: c3 ret 10c9de: 66 90 xchg %ax,%ax if ( proxy_extract_callout ) (*proxy_extract_callout)( the_thread ); } #endif _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10c9e0: 83 ec 08 sub $0x8,%esp 10c9e3: 50 push %eax 10c9e4: ff 70 44 pushl 0x44(%eax) 10c9e7: e8 60 2c 00 00 call 10f64c <_Thread_queue_Extract> 10c9ec: b0 01 mov $0x1,%al 10c9ee: 83 c4 10 add $0x10,%esp return TRUE; } return FALSE; } 10c9f1: c9 leave 10c9f2: c3 ret =============================================================================== 0011aa6c <_Thread_queue_First_priority>: */ Thread_Control *_Thread_queue_First_priority ( Thread_queue_Control *the_thread_queue ) { 11aa6c: 55 push %ebp 11aa6d: 89 e5 mov %esp,%ebp 11aa6f: 56 push %esi 11aa70: 53 push %ebx 11aa71: 8b 75 08 mov 0x8(%ebp),%esi 11aa74: 31 d2 xor %edx,%edx 11aa76: 31 c9 xor %ecx,%ecx * 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( 11aa78: 8b 1c 0e mov (%esi,%ecx,1),%ebx 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 ] ) ) 11aa7b: 8d 04 52 lea (%edx,%edx,2),%eax 11aa7e: 8d 44 86 04 lea 0x4(%esi,%eax,4),%eax 11aa82: 39 c3 cmp %eax,%ebx 11aa84: 75 12 jne 11aa98 <_Thread_queue_First_priority+0x2c> { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; index++ ) { 11aa86: 42 inc %edx 11aa87: 83 c1 0c add $0xc,%ecx ) { uint32_t index; for( index=0 ; index < TASK_QUEUE_DATA_NUMBER_OF_PRIORITY_HEADERS ; 11aa8a: 83 fa 04 cmp $0x4,%edx 11aa8d: 75 e9 jne 11aa78 <_Thread_queue_First_priority+0xc> 11aa8f: 31 c0 xor %eax,%eax if ( !_Chain_Is_empty( &the_thread_queue->Queues.Priority[ index ] ) ) return (Thread_Control *) the_thread_queue->Queues.Priority[ index ].first; } return NULL; } 11aa91: 5b pop %ebx 11aa92: 5e pop %esi 11aa93: c9 leave 11aa94: c3 ret 11aa95: 8d 76 00 lea 0x0(%esi),%esi 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 *) 11aa98: 89 d8 mov %ebx,%eax the_thread_queue->Queues.Priority[ index ].first; } return NULL; } 11aa9a: 5b pop %ebx 11aa9b: 5e pop %esi 11aa9c: c9 leave 11aa9d: c3 ret =============================================================================== 0010c9f4 <_Thread_queue_Flush>: void _Thread_queue_Flush( Thread_queue_Control *the_thread_queue, Thread_queue_Flush_callout remote_extract_callout, uint32_t status ) { 10c9f4: 55 push %ebp 10c9f5: 89 e5 mov %esp,%ebp 10c9f7: 56 push %esi 10c9f8: 53 push %ebx 10c9f9: 8b 75 08 mov 0x8(%ebp),%esi 10c9fc: 8b 5d 10 mov 0x10(%ebp),%ebx 10c9ff: eb 06 jmp 10ca07 <_Thread_queue_Flush+0x13> 10ca01: 8d 76 00 lea 0x0(%esi),%esi #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; 10ca04: 89 58 34 mov %ebx,0x34(%eax) uint32_t status ) { Thread_Control *the_thread; while ( (the_thread = _Thread_queue_Dequeue( the_thread_queue )) ) { 10ca07: 83 ec 0c sub $0xc,%esp 10ca0a: 56 push %esi 10ca0b: e8 60 fc ff ff call 10c670 <_Thread_queue_Dequeue> 10ca10: 83 c4 10 add $0x10,%esp 10ca13: 85 c0 test %eax,%eax 10ca15: 75 ed jne 10ca04 <_Thread_queue_Flush+0x10> ( *remote_extract_callout )( the_thread ); else #endif the_thread->Wait.return_code = status; } } 10ca17: 8d 65 f8 lea -0x8(%ebp),%esp 10ca1a: 5b pop %ebx 10ca1b: 5e pop %esi 10ca1c: c9 leave 10ca1d: c3 ret =============================================================================== 0010f740 <_Thread_queue_Process_timeout>: #include void _Thread_queue_Process_timeout( Thread_Control *the_thread ) { 10f740: 55 push %ebp 10f741: 89 e5 mov %esp,%ebp 10f743: 83 ec 08 sub $0x8,%esp 10f746: 8b 4d 08 mov 0x8(%ebp),%ecx Thread_queue_Control *the_thread_queue = the_thread->Wait.queue; 10f749: 8b 51 44 mov 0x44(%ecx),%edx * 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 && 10f74c: 8b 42 30 mov 0x30(%edx),%eax 10f74f: 85 c0 test %eax,%eax 10f751: 74 08 je 10f75b <_Thread_queue_Process_timeout+0x1b> 10f753: 3b 0d 1c e7 11 00 cmp 0x11e71c,%ecx 10f759: 74 19 je 10f774 <_Thread_queue_Process_timeout+0x34><== ALWAYS TAKEN 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; 10f75b: 8b 42 3c mov 0x3c(%edx),%eax 10f75e: 89 41 34 mov %eax,0x34(%ecx) _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); 10f761: 83 ec 08 sub $0x8,%esp 10f764: 51 push %ecx 10f765: ff 71 44 pushl 0x44(%ecx) 10f768: e8 df fe ff ff call 10f64c <_Thread_queue_Extract> 10f76d: 83 c4 10 add $0x10,%esp } } 10f770: c9 leave 10f771: c3 ret 10f772: 66 90 xchg %ax,%ax * 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 ) { 10f774: 83 f8 03 cmp $0x3,%eax 10f777: 74 f7 je 10f770 <_Thread_queue_Process_timeout+0x30><== NEVER TAKEN the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; 10f779: 8b 42 3c mov 0x3c(%edx),%eax 10f77c: 89 41 34 mov %eax,0x34(%ecx) the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT; 10f77f: c7 42 30 02 00 00 00 movl $0x2,0x30(%edx) } } else { the_thread->Wait.return_code = the_thread->Wait.queue->timeout_status; _Thread_queue_Extract( the_thread->Wait.queue, the_thread ); } } 10f786: c9 leave 10f787: c3 ret =============================================================================== 0010caa0 <_Thread_queue_Requeue>: void _Thread_queue_Requeue( Thread_queue_Control *the_thread_queue, Thread_Control *the_thread ) { 10caa0: 55 push %ebp 10caa1: 89 e5 mov %esp,%ebp 10caa3: 56 push %esi 10caa4: 53 push %ebx 10caa5: 83 ec 10 sub $0x10,%esp 10caa8: 8b 5d 08 mov 0x8(%ebp),%ebx /* * Just in case the thread really wasn't blocked on a thread queue * when we get here. */ if ( !the_thread_queue ) 10caab: 85 db test %ebx,%ebx 10caad: 74 06 je 10cab5 <_Thread_queue_Requeue+0x15><== NEVER TAKEN /* * 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 ) { 10caaf: 83 7b 34 01 cmpl $0x1,0x34(%ebx) 10cab3: 74 07 je 10cabc <_Thread_queue_Requeue+0x1c><== ALWAYS TAKEN _Thread_queue_Extract_priority_helper( tq, the_thread, TRUE ); (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); } _ISR_Enable( level ); } } 10cab5: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10cab8: 5b pop %ebx <== NOT EXECUTED 10cab9: 5e pop %esi <== NOT EXECUTED 10caba: c9 leave <== NOT EXECUTED 10cabb: 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 ); 10cabc: 9c pushf 10cabd: fa cli 10cabe: 5e pop %esi if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) { 10cabf: 8b 45 0c mov 0xc(%ebp),%eax 10cac2: f7 40 10 e0 be 03 00 testl $0x3bee0,0x10(%eax) 10cac9: 75 09 jne 10cad4 <_Thread_queue_Requeue+0x34><== ALWAYS TAKEN _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 ); 10cacb: 56 push %esi 10cacc: 9d popf } } 10cacd: 8d 65 f8 lea -0x8(%ebp),%esp 10cad0: 5b pop %ebx 10cad1: 5e pop %esi 10cad2: c9 leave 10cad3: c3 ret { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10cad4: c7 43 30 01 00 00 00 movl $0x1,0x30(%ebx) 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 ); 10cadb: 52 push %edx 10cadc: 6a 01 push $0x1 10cade: 50 push %eax 10cadf: 53 push %ebx 10cae0: e8 97 2b 00 00 call 10f67c <_Thread_queue_Extract_priority_helper> (void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored ); 10cae5: 83 c4 0c add $0xc,%esp 10cae8: 8d 45 f4 lea -0xc(%ebp),%eax 10caeb: 50 push %eax 10caec: ff 75 0c pushl 0xc(%ebp) 10caef: 53 push %ebx 10caf0: e8 4f fd ff ff call 10c844 <_Thread_queue_Enqueue_priority> 10caf5: 83 c4 10 add $0x10,%esp 10caf8: eb d1 jmp 10cacb <_Thread_queue_Requeue+0x2b> =============================================================================== 0010cafc <_Thread_queue_Timeout>: void _Thread_queue_Timeout( Objects_Id id, void *ignored ) { 10cafc: 55 push %ebp 10cafd: 89 e5 mov %esp,%ebp 10caff: 83 ec 20 sub $0x20,%esp Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10cb02: 8d 45 fc lea -0x4(%ebp),%eax 10cb05: 50 push %eax 10cb06: ff 75 08 pushl 0x8(%ebp) 10cb09: e8 02 f8 ff ff call 10c310 <_Thread_Get> switch ( location ) { 10cb0e: 83 c4 10 add $0x10,%esp 10cb11: 8b 55 fc mov -0x4(%ebp),%edx 10cb14: 85 d2 test %edx,%edx 10cb16: 75 17 jne 10cb2f <_Thread_queue_Timeout+0x33><== NEVER TAKEN #if defined(RTEMS_MULTIPROCESSING) case OBJECTS_REMOTE: /* impossible */ #endif break; case OBJECTS_LOCAL: _Thread_queue_Process_timeout( the_thread ); 10cb18: 83 ec 0c sub $0xc,%esp 10cb1b: 50 push %eax 10cb1c: e8 1f 2c 00 00 call 10f740 <_Thread_queue_Process_timeout> 10cb21: a1 58 e6 11 00 mov 0x11e658,%eax 10cb26: 48 dec %eax 10cb27: a3 58 e6 11 00 mov %eax,0x11e658 10cb2c: 83 c4 10 add $0x10,%esp _Thread_Unnest_dispatch(); break; } } 10cb2f: c9 leave 10cb30: c3 ret =============================================================================== 00114ca0 <_Timer_Server_body>: * @param[in] ignored is the the task argument that is ignored */ Thread _Timer_Server_body( uint32_t ignored ) { 114ca0: 55 push %ebp 114ca1: 89 e5 mov %esp,%ebp 114ca3: 57 push %edi 114ca4: 56 push %esi 114ca5: 53 push %ebx 114ca6: 83 ec 1c sub $0x1c,%esp * @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 114ca9: 8d 7d e8 lea -0x18(%ebp),%edi 114cac: 8d 75 ec lea -0x14(%ebp),%esi 114caf: 89 75 e8 mov %esi,-0x18(%ebp) 114cb2: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp) 114cb9: 89 7d f0 mov %edi,-0x10(%ebp) /* * Initialize the "last time" markers to indicate the timer that * the server was initiated. */ _Timer_Server_ticks_last_time = _Watchdog_Ticks_since_boot; 114cbc: a1 a4 5b 13 00 mov 0x135ba4,%eax 114cc1: a3 90 59 13 00 mov %eax,0x135990 _Timer_Server_seconds_last_time = _TOD_Seconds_since_epoch; 114cc6: a1 cc 5a 13 00 mov 0x135acc,%eax 114ccb: a3 8c 59 13 00 mov %eax,0x13598c /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 114cd0: a1 38 5a 13 00 mov 0x135a38,%eax 114cd5: 40 inc %eax 114cd6: a3 38 5a 13 00 mov %eax,0x135a38 /* * 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(); 114cdb: e8 60 ff ff ff call 114c40 <_Timer_Server_process_insertions> _Thread_Enable_dispatch(); 114ce0: e8 3f 27 00 00 call 117424 <_Thread_Enable_dispatch> 114ce5: 8d 76 00 lea 0x0(%esi),%esi 114ce8: a1 38 5a 13 00 mov 0x135a38,%eax 114ced: 40 inc %eax 114cee: a3 38 5a 13 00 mov %eax,0x135a38 /* * Block until there is something to do. */ _Thread_Disable_dispatch(); _Thread_Set_state( _Timer_Server, STATES_DELAYING ); 114cf3: 83 ec 08 sub $0x8,%esp 114cf6: 6a 08 push $0x8 114cf8: ff 35 e4 5d 13 00 pushl 0x135de4 114cfe: e8 19 31 00 00 call 117e1c <_Thread_Set_state> * 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( 114d03: 8b 15 80 59 13 00 mov 0x135980,%edx _Timer_Server_reset_ticks_timer(); 114d09: 83 c4 10 add $0x10,%esp 114d0c: 81 fa 84 59 13 00 cmp $0x135984,%edx 114d12: 74 1f je 114d33 <_Timer_Server_body+0x93> 114d14: a1 e4 5d 13 00 mov 0x135de4,%eax Heap_Control *the_heap, 114d19: 8b 52 10 mov 0x10(%edx),%edx 114d1c: 89 50 54 mov %edx,0x54(%eax) void *starting_address, size_t *size 114d1f: 83 ec 08 sub $0x8,%esp 114d22: 83 c0 48 add $0x48,%eax 114d25: 50 push %eax 114d26: 68 1c 5b 13 00 push $0x135b1c 114d2b: e8 bc 39 00 00 call 1186ec <_Watchdog_Insert> 114d30: 83 c4 10 add $0x10,%esp * 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( 114d33: a1 94 59 13 00 mov 0x135994,%eax _Timer_Server_reset_seconds_timer(); 114d38: 3d 98 59 13 00 cmp $0x135998,%eax 114d3d: 74 1d je 114d5c <_Timer_Server_body+0xbc> * @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, 114d3f: 8b 40 10 mov 0x10(%eax),%eax 114d42: a3 cc 59 13 00 mov %eax,0x1359cc size_t size ); 114d47: 83 ec 08 sub $0x8,%esp 114d4a: 68 c0 59 13 00 push $0x1359c0 114d4f: 68 10 5b 13 00 push $0x135b10 114d54: e8 93 39 00 00 call 1186ec <_Watchdog_Insert> 114d59: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 114d5c: e8 c3 26 00 00 call 117424 <_Thread_Enable_dispatch> /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 114d61: a1 38 5a 13 00 mov 0x135a38,%eax 114d66: 40 inc %eax 114d67: a3 38 5a 13 00 mov %eax,0x135a38 /* * 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(); 114d6c: 83 ec 0c sub $0xc,%esp 114d6f: a1 e4 5d 13 00 mov 0x135de4,%eax 114d74: 83 c0 48 add $0x48,%eax 114d77: 50 push %eax 114d78: e8 9f 3a 00 00 call 11881c <_Watchdog_Remove> _Timer_Server_stop_seconds_timer(); 114d7d: c7 04 24 c0 59 13 00 movl $0x1359c0,(%esp) 114d84: e8 93 3a 00 00 call 11881c <_Watchdog_Remove> ) { Watchdog_Interval snapshot; Watchdog_Interval ticks; snapshot = _Watchdog_Ticks_since_boot; 114d89: 8b 15 a4 5b 13 00 mov 0x135ba4,%edx if ( snapshot >= _Timer_Server_ticks_last_time ) 114d8f: a1 90 59 13 00 mov 0x135990,%eax 114d94: 83 c4 10 add $0x10,%esp 114d97: 39 c2 cmp %eax,%edx 114d99: 72 7d jb 114e18 <_Timer_Server_body+0x178><== NEVER TAKEN ticks = snapshot - _Timer_Server_ticks_last_time; 114d9b: 89 d1 mov %edx,%ecx 114d9d: 29 c1 sub %eax,%ecx 114d9f: 89 c8 mov %ecx,%eax else ticks = (0xFFFFFFFF - _Timer_Server_ticks_last_time) + snapshot; _Timer_Server_ticks_last_time = snapshot; 114da1: 89 15 90 59 13 00 mov %edx,0x135990 _Watchdog_Adjust_to_chain( &_Timer_Ticks_chain, ticks, to_fire ); 114da7: 53 push %ebx 114da8: 57 push %edi 114da9: 50 push %eax 114daa: 68 80 59 13 00 push $0x135980 114daf: e8 a4 38 00 00 call 118658 <_Watchdog_Adjust_to_chain> /* * Process the seconds chain. Start by checking that the Time * of Day (TOD) has not been set backwards. If it has then * we want to adjust the _Timer_Seconds_chain to indicate this. */ snapshot = _TOD_Seconds_since_epoch; 114db4: 8b 1d cc 5a 13 00 mov 0x135acc,%ebx if ( snapshot > _Timer_Server_seconds_last_time ) { 114dba: a1 8c 59 13 00 mov 0x13598c,%eax 114dbf: 83 c4 10 add $0x10,%esp 114dc2: 39 c3 cmp %eax,%ebx 114dc4: 77 5a ja 114e20 <_Timer_Server_body+0x180> * 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 ) { 114dc6: 72 70 jb 114e38 <_Timer_Server_body+0x198> * 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; 114dc8: 89 1d 8c 59 13 00 mov %ebx,0x13598c _Timer_Server_process_seconds_chain( &to_fire ); /* * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); 114dce: e8 6d fe ff ff call 114c40 <_Timer_Server_process_insertions> /* * Enable dispatching to process the set that are ready "to fire." */ _Thread_Enable_dispatch(); 114dd3: e8 4c 26 00 00 call 117424 <_Thread_Enable_dispatch> */ while (1) { Watchdog_Control *watch; ISR_Level level; _ISR_Disable( level ); 114dd8: 9c pushf 114dd9: fa cli 114dda: 59 pop %ecx * 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( 114ddb: 8b 55 e8 mov -0x18(%ebp),%edx 114dde: 39 d6 cmp %edx,%esi 114de0: 74 2c je 114e0e <_Timer_Server_body+0x16e> 114de2: 66 90 xchg %ax,%ax 114de4: 8b 02 mov (%edx),%eax 114de6: 89 45 e8 mov %eax,-0x18(%ebp) 114de9: 89 78 04 mov %edi,0x4(%eax) if ( watch == NULL ) { _ISR_Enable( level ); break; } watch->state = WATCHDOG_INACTIVE; 114dec: c7 42 08 00 00 00 00 movl $0x0,0x8(%edx) _ISR_Enable( level ); 114df3: 51 push %ecx 114df4: 9d popf (*watch->routine)( watch->id, watch->user_data ); 114df5: 83 ec 08 sub $0x8,%esp 114df8: ff 72 24 pushl 0x24(%edx) 114dfb: ff 72 20 pushl 0x20(%edx) 114dfe: ff 52 1c call *0x1c(%edx) */ while (1) { Watchdog_Control *watch; ISR_Level level; _ISR_Disable( level ); 114e01: 9c pushf 114e02: fa cli 114e03: 59 pop %ecx * 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( 114e04: 8b 55 e8 mov -0x18(%ebp),%edx 114e07: 83 c4 10 add $0x10,%esp 114e0a: 39 d6 cmp %edx,%esi 114e0c: 75 d6 jne 114de4 <_Timer_Server_body+0x144> watch = (Watchdog_Control *) _Chain_Get_unprotected( &to_fire ); if ( watch == NULL ) { _ISR_Enable( level ); 114e0e: 51 push %ecx 114e0f: 9d popf 114e10: e9 d3 fe ff ff jmp 114ce8 <_Timer_Server_body+0x48> 114e15: 8d 76 00 lea 0x0(%esi),%esi 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; 114e18: f7 d0 not %eax <== NOT EXECUTED 114e1a: 01 d0 add %edx,%eax <== NOT EXECUTED 114e1c: eb 83 jmp 114da1 <_Timer_Server_body+0x101><== NOT EXECUTED 114e1e: 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 ); 114e20: 51 push %ecx 114e21: 57 push %edi 114e22: 89 da mov %ebx,%edx 114e24: 29 c2 sub %eax,%edx 114e26: 52 push %edx 114e27: 68 94 59 13 00 push $0x135994 114e2c: e8 27 38 00 00 call 118658 <_Watchdog_Adjust_to_chain> 114e31: 83 c4 10 add $0x10,%esp 114e34: eb 92 jmp 114dc8 <_Timer_Server_body+0x128> 114e36: 66 90 xchg %ax,%ax /* * 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 ); 114e38: 52 push %edx 114e39: 29 d8 sub %ebx,%eax 114e3b: 50 push %eax 114e3c: 6a 01 push $0x1 114e3e: 68 94 59 13 00 push $0x135994 114e43: e8 94 37 00 00 call 1185dc <_Watchdog_Adjust> 114e48: 83 c4 10 add $0x10,%esp 114e4b: e9 78 ff ff ff jmp 114dc8 <_Timer_Server_body+0x128> =============================================================================== 00114c40 <_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) { 114c40: 55 push %ebp 114c41: 89 e5 mov %esp,%ebp 114c43: 83 ec 08 sub $0x8,%esp 114c46: eb 0a jmp 114c52 <_Timer_Server_process_insertions+0x12> 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 ) { 114c48: 83 fa 03 cmp $0x3,%edx 114c4b: 74 37 je 114c84 <_Timer_Server_process_insertions+0x44><== ALWAYS TAKEN } /* * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); 114c4d: e8 ee ff ff ff call 114c40 <_Timer_Server_process_insertions> static void _Timer_Server_process_insertions(void) { Timer_Control *the_timer; while ( 1 ) { the_timer = (Timer_Control *) _Chain_Get( &_Timer_To_be_inserted ); 114c52: 83 ec 0c sub $0xc,%esp 114c55: 68 a0 59 13 00 push $0x1359a0 114c5a: e8 69 08 00 00 call 1154c8 <_Chain_Get> if ( the_timer == NULL ) 114c5f: 83 c4 10 add $0x10,%esp 114c62: 85 c0 test %eax,%eax 114c64: 74 36 je 114c9c <_Timer_Server_process_insertions+0x5c> break; if ( the_timer->the_class == TIMER_INTERVAL_ON_TASK ) { 114c66: 8b 50 38 mov 0x38(%eax),%edx 114c69: 83 fa 01 cmp $0x1,%edx 114c6c: 75 da jne 114c48 <_Timer_Server_process_insertions+0x8> _Watchdog_Insert( &_Timer_Ticks_chain, &the_timer->Ticker ); 114c6e: 83 ec 08 sub $0x8,%esp 114c71: 83 c0 10 add $0x10,%eax 114c74: 50 push %eax 114c75: 68 80 59 13 00 push $0x135980 114c7a: e8 6d 3a 00 00 call 1186ec <_Watchdog_Insert> 114c7f: 83 c4 10 add $0x10,%esp 114c82: eb c9 jmp 114c4d <_Timer_Server_process_insertions+0xd> } else if ( the_timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) { _Watchdog_Insert( &_Timer_Seconds_chain, &the_timer->Ticker ); 114c84: 83 ec 08 sub $0x8,%esp 114c87: 83 c0 10 add $0x10,%eax 114c8a: 50 push %eax 114c8b: 68 94 59 13 00 push $0x135994 114c90: e8 57 3a 00 00 call 1186ec <_Watchdog_Insert> 114c95: 83 c4 10 add $0x10,%esp 114c98: eb b3 jmp 114c4d <_Timer_Server_process_insertions+0xd> 114c9a: 66 90 xchg %ax,%ax * Insert the timers that have been requested to be inserted. */ _Timer_Server_process_insertions(); } } 114c9c: c9 leave 114c9d: c3 ret =============================================================================== 0010e5d8 <_Timespec_Divide>: const struct timespec *lhs, const struct timespec *rhs, uint32_t *ival_percentage, uint32_t *fval_percentage ) { 10e5d8: 55 push %ebp 10e5d9: 89 e5 mov %esp,%ebp 10e5db: 57 push %edi 10e5dc: 56 push %esi 10e5dd: 53 push %ebx 10e5de: 83 ec 2c sub $0x2c,%esp 10e5e1: 8b 45 08 mov 0x8(%ebp),%eax /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10e5e4: 8b 10 mov (%eax),%edx 10e5e6: 89 55 ec mov %edx,-0x14(%ebp) left += lhs->tv_nsec; 10e5e9: 8b 40 04 mov 0x4(%eax),%eax 10e5ec: 89 45 dc mov %eax,-0x24(%ebp) right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10e5ef: b9 00 ca 9a 3b mov $0x3b9aca00,%ecx 10e5f4: 8b 5d 0c mov 0xc(%ebp),%ebx 10e5f7: 8b 03 mov (%ebx),%eax 10e5f9: f7 e9 imul %ecx 10e5fb: 89 c6 mov %eax,%esi 10e5fd: 89 d7 mov %edx,%edi right += rhs->tv_nsec; 10e5ff: 8b 43 04 mov 0x4(%ebx),%eax 10e602: 99 cltd 10e603: 01 c6 add %eax,%esi 10e605: 11 d7 adc %edx,%edi if ( right == 0 ) { 10e607: 89 f8 mov %edi,%eax 10e609: 09 f0 or %esi,%eax 10e60b: 74 77 je 10e684 <_Timespec_Divide+0xac> <== NEVER TAKEN /* * For math simplicity just convert the timespec to nanoseconds * in a 64-bit integer. */ left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; 10e60d: 8b 45 ec mov -0x14(%ebp),%eax 10e610: f7 e9 imul %ecx 10e612: 89 45 e0 mov %eax,-0x20(%ebp) 10e615: 89 55 e4 mov %edx,-0x1c(%ebp) * Put it back in the timespec result. * * TODO: Rounding on the last digit of the fval. */ answer = (left * 100000) / right; 10e618: 8b 45 dc mov -0x24(%ebp),%eax 10e61b: 99 cltd 10e61c: 01 45 e0 add %eax,-0x20(%ebp) 10e61f: 11 55 e4 adc %edx,-0x1c(%ebp) 10e622: 69 5d e4 a0 86 01 00 imul $0x186a0,-0x1c(%ebp),%ebx 10e629: b9 a0 86 01 00 mov $0x186a0,%ecx 10e62e: 8b 45 e0 mov -0x20(%ebp),%eax 10e631: f7 e1 mul %ecx 10e633: 89 45 d0 mov %eax,-0x30(%ebp) 10e636: 01 da add %ebx,%edx 10e638: 89 55 d4 mov %edx,-0x2c(%ebp) 10e63b: 57 push %edi 10e63c: 56 push %esi 10e63d: ff 75 d4 pushl -0x2c(%ebp) 10e640: ff 75 d0 pushl -0x30(%ebp) 10e643: e8 c0 a8 00 00 call 118f08 <__udivdi3> 10e648: 83 c4 10 add $0x10,%esp 10e64b: 89 c3 mov %eax,%ebx 10e64d: 89 d6 mov %edx,%esi *ival_percentage = answer / 1000; 10e64f: 6a 00 push $0x0 10e651: 68 e8 03 00 00 push $0x3e8 10e656: 52 push %edx 10e657: 50 push %eax 10e658: e8 ab a8 00 00 call 118f08 <__udivdi3> 10e65d: 83 c4 10 add $0x10,%esp 10e660: 8b 4d 10 mov 0x10(%ebp),%ecx 10e663: 89 01 mov %eax,(%ecx) *fval_percentage = answer % 1000; 10e665: 6a 00 push $0x0 10e667: 68 e8 03 00 00 push $0x3e8 10e66c: 56 push %esi 10e66d: 53 push %ebx 10e66e: e8 a1 a9 00 00 call 119014 <__umoddi3> 10e673: 83 c4 10 add $0x10,%esp 10e676: 8b 5d 14 mov 0x14(%ebp),%ebx 10e679: 89 03 mov %eax,(%ebx) } 10e67b: 8d 65 f4 lea -0xc(%ebp),%esp 10e67e: 5b pop %ebx 10e67f: 5e pop %esi 10e680: 5f pop %edi 10e681: c9 leave 10e682: c3 ret 10e683: 90 nop left += lhs->tv_nsec; right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND; right += rhs->tv_nsec; if ( right == 0 ) { *ival_percentage = 0; 10e684: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10e687: c7 02 00 00 00 00 movl $0x0,(%edx) <== NOT EXECUTED *fval_percentage = 0; 10e68d: 8b 4d 14 mov 0x14(%ebp),%ecx <== NOT EXECUTED 10e690: c7 01 00 00 00 00 movl $0x0,(%ecx) <== NOT EXECUTED answer = (left * 100000) / right; *ival_percentage = answer / 1000; *fval_percentage = answer % 1000; } 10e696: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e699: 5b pop %ebx <== NOT EXECUTED 10e69a: 5e pop %esi <== NOT EXECUTED 10e69b: 5f pop %edi <== NOT EXECUTED 10e69c: c9 leave <== NOT EXECUTED 10e69d: c3 ret <== NOT EXECUTED =============================================================================== 0010ea08 <_Timespec_Greater_than>: bool _Timespec_Greater_than( const struct timespec *lhs, const struct timespec *rhs ) { 10ea08: 55 push %ebp 10ea09: 89 e5 mov %esp,%ebp 10ea0b: 8b 55 08 mov 0x8(%ebp),%edx 10ea0e: 8b 4d 0c mov 0xc(%ebp),%ecx if ( lhs->tv_sec > rhs->tv_sec ) 10ea11: 8b 01 mov (%ecx),%eax 10ea13: 39 02 cmp %eax,(%edx) 10ea15: 7f 11 jg 10ea28 <_Timespec_Greater_than+0x20><== NEVER TAKEN return TRUE; if ( lhs->tv_sec < rhs->tv_sec ) 10ea17: 7c 0b jl 10ea24 <_Timespec_Greater_than+0x1c><== NEVER TAKEN return FALSE; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec > rhs->tv_nsec ) 10ea19: 8b 42 04 mov 0x4(%edx),%eax 10ea1c: 3b 41 04 cmp 0x4(%ecx),%eax 10ea1f: 0f 9f c0 setg %al return TRUE; return FALSE; } 10ea22: c9 leave 10ea23: c3 ret ) { if ( lhs->tv_sec > rhs->tv_sec ) return TRUE; if ( lhs->tv_sec < rhs->tv_sec ) 10ea24: 31 c0 xor %eax,%eax /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec > rhs->tv_nsec ) return TRUE; return FALSE; } 10ea26: c9 leave <== NOT EXECUTED 10ea27: c3 ret <== NOT EXECUTED bool _Timespec_Greater_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec > rhs->tv_sec ) 10ea28: 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; } 10ea2a: c9 leave <== NOT EXECUTED 10ea2b: c3 ret <== NOT EXECUTED =============================================================================== 0010ea2c <_Timespec_Less_than>: bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { 10ea2c: 55 push %ebp 10ea2d: 89 e5 mov %esp,%ebp 10ea2f: 8b 55 08 mov 0x8(%ebp),%edx 10ea32: 8b 4d 0c mov 0xc(%ebp),%ecx if ( lhs->tv_sec < rhs->tv_sec ) 10ea35: 8b 01 mov (%ecx),%eax 10ea37: 39 02 cmp %eax,(%edx) 10ea39: 7c 11 jl 10ea4c <_Timespec_Less_than+0x20> return TRUE; if ( lhs->tv_sec > rhs->tv_sec ) 10ea3b: 7f 0b jg 10ea48 <_Timespec_Less_than+0x1c><== NEVER TAKEN return FALSE; /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) 10ea3d: 8b 42 04 mov 0x4(%edx),%eax 10ea40: 3b 41 04 cmp 0x4(%ecx),%eax 10ea43: 0f 9c c0 setl %al return TRUE; return FALSE; } 10ea46: c9 leave 10ea47: c3 ret ) { if ( lhs->tv_sec < rhs->tv_sec ) return TRUE; if ( lhs->tv_sec > rhs->tv_sec ) 10ea48: 31 c0 xor %eax,%eax /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) return TRUE; return FALSE; } 10ea4a: c9 leave <== NOT EXECUTED 10ea4b: c3 ret <== NOT EXECUTED bool _Timespec_Less_than( const struct timespec *lhs, const struct timespec *rhs ) { if ( lhs->tv_sec < rhs->tv_sec ) 10ea4c: b0 01 mov $0x1,%al /* ASSERT: lhs->tv_sec == rhs->tv_sec */ if ( lhs->tv_nsec < rhs->tv_nsec ) return TRUE; return FALSE; } 10ea4e: c9 leave 10ea4f: c3 ret =============================================================================== 0010f88c <_User_extensions_Add_API_set>: */ void _User_extensions_Add_API_set ( User_extensions_Control *the_extension ) { 10f88c: 55 push %ebp 10f88d: 89 e5 mov %esp,%ebp 10f88f: 53 push %ebx 10f890: 83 ec 0c sub $0xc,%esp 10f893: 8b 5d 08 mov 0x8(%ebp),%ebx _Chain_Append( &_User_extensions_List, &the_extension->Node ); 10f896: 53 push %ebx 10f897: 68 ac e8 11 00 push $0x11e8ac 10f89c: e8 db b4 ff ff call 10ad7c <_Chain_Append> /* * If a switch handler is present, append it to the switch chain. */ if ( the_extension->Callouts.thread_switch != NULL ) { 10f8a1: 8b 43 24 mov 0x24(%ebx),%eax 10f8a4: 83 c4 10 add $0x10,%esp 10f8a7: 85 c0 test %eax,%eax 10f8a9: 74 17 je 10f8c2 <_User_extensions_Add_API_set+0x36><== NEVER TAKEN the_extension->Switch.thread_switch = the_extension->Callouts.thread_switch; 10f8ab: 89 43 10 mov %eax,0x10(%ebx) _Chain_Append( 10f8ae: 83 ec 08 sub $0x8,%esp 10f8b1: 8d 43 08 lea 0x8(%ebx),%eax 10f8b4: 50 push %eax 10f8b5: 68 5c e6 11 00 push $0x11e65c 10f8ba: e8 bd b4 ff ff call 10ad7c <_Chain_Append> 10f8bf: 83 c4 10 add $0x10,%esp &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10f8c2: 8b 5d fc mov -0x4(%ebp),%ebx 10f8c5: c9 leave 10f8c6: c3 ret =============================================================================== 0010f8c8 <_User_extensions_Add_set>: void _User_extensions_Add_set ( User_extensions_Control *the_extension, User_extensions_Table *extension_table ) { 10f8c8: 55 push %ebp 10f8c9: 89 e5 mov %esp,%ebp 10f8cb: 57 push %edi 10f8cc: 56 push %esi 10f8cd: 53 push %ebx 10f8ce: 83 ec 14 sub $0x14,%esp 10f8d1: 8b 5d 08 mov 0x8(%ebp),%ebx 10f8d4: 8b 45 0c mov 0xc(%ebp),%eax 10f8d7: 89 45 ec mov %eax,-0x14(%ebp) the_extension->Callouts = *extension_table; 10f8da: 8d 7b 14 lea 0x14(%ebx),%edi 10f8dd: b9 08 00 00 00 mov $0x8,%ecx 10f8e2: 89 c6 mov %eax,%esi 10f8e4: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Chain_Append( &_User_extensions_List, &the_extension->Node ); 10f8e6: 53 push %ebx 10f8e7: 68 ac e8 11 00 push $0x11e8ac 10f8ec: e8 8b b4 ff ff call 10ad7c <_Chain_Append> /* * If a switch handler is present, append it to the switch chain. */ if ( extension_table->thread_switch != NULL ) { 10f8f1: 8b 55 ec mov -0x14(%ebp),%edx 10f8f4: 8b 42 10 mov 0x10(%edx),%eax 10f8f7: 83 c4 10 add $0x10,%esp 10f8fa: 85 c0 test %eax,%eax 10f8fc: 74 1e je 10f91c <_User_extensions_Add_set+0x54> the_extension->Switch.thread_switch = extension_table->thread_switch; 10f8fe: 89 43 10 mov %eax,0x10(%ebx) _Chain_Append( 10f901: 8d 43 08 lea 0x8(%ebx),%eax 10f904: 89 45 0c mov %eax,0xc(%ebp) 10f907: c7 45 08 5c e6 11 00 movl $0x11e65c,0x8(%ebp) &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10f90e: 8d 65 f4 lea -0xc(%ebp),%esp 10f911: 5b pop %ebx 10f912: 5e pop %esi 10f913: 5f pop %edi 10f914: c9 leave * 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( 10f915: e9 62 b4 ff ff jmp 10ad7c <_Chain_Append> 10f91a: 66 90 xchg %ax,%ax &_User_extensions_Switches_list, &the_extension->Switch.Node ); } } 10f91c: 8d 65 f4 lea -0xc(%ebp),%esp 10f91f: 5b pop %ebx 10f920: 5e pop %esi 10f921: 5f pop %edi 10f922: c9 leave 10f923: c3 ret =============================================================================== 0010d0ac <_User_extensions_Fatal>: void _User_extensions_Fatal ( Internal_errors_Source the_source, bool is_internal, uint32_t the_error ) { 10d0ac: 55 push %ebp 10d0ad: 89 e5 mov %esp,%ebp 10d0af: 57 push %edi 10d0b0: 56 push %esi 10d0b1: 53 push %ebx 10d0b2: 83 ec 0c sub $0xc,%esp 10d0b5: 8b 7d 10 mov 0x10(%ebp),%edi 10d0b8: 8a 45 0c mov 0xc(%ebp),%al Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10d0bb: 8b 1d b4 e8 11 00 mov 0x11e8b4,%ebx !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d0c1: 81 fb ac e8 11 00 cmp $0x11e8ac,%ebx 10d0c7: 74 20 je 10d0e9 <_User_extensions_Fatal+0x3d><== NEVER TAKEN 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 ); 10d0c9: 0f b6 f0 movzbl %al,%esi !_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 ) 10d0cc: 8b 43 30 mov 0x30(%ebx),%eax 10d0cf: 85 c0 test %eax,%eax 10d0d1: 74 0b je 10d0de <_User_extensions_Fatal+0x32> (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); 10d0d3: 52 push %edx 10d0d4: 57 push %edi 10d0d5: 56 push %esi 10d0d6: ff 75 08 pushl 0x8(%ebp) 10d0d9: ff d0 call *%eax 10d0db: 83 c4 10 add $0x10,%esp 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 ) { 10d0de: 8b 5b 04 mov 0x4(%ebx),%ebx { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d0e1: 81 fb ac e8 11 00 cmp $0x11e8ac,%ebx 10d0e7: 75 e3 jne 10d0cc <_User_extensions_Fatal+0x20> the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.fatal != NULL ) (*the_extension->Callouts.fatal)( the_source, is_internal, the_error ); } } 10d0e9: 8d 65 f4 lea -0xc(%ebp),%esp 10d0ec: 5b pop %ebx 10d0ed: 5e pop %esi 10d0ee: 5f pop %edi 10d0ef: c9 leave 10d0f0: c3 ret =============================================================================== 0010cf90 <_User_extensions_Handler_initialization>: void _User_extensions_Handler_initialization ( uint32_t number_of_extensions, User_extensions_Table *initial_extensions ) { 10cf90: 55 push %ebp 10cf91: 89 e5 mov %esp,%ebp 10cf93: 57 push %edi 10cf94: 56 push %esi 10cf95: 53 push %ebx 10cf96: 83 ec 0c sub $0xc,%esp 10cf99: 8b 75 0c mov 0xc(%ebp),%esi 10cf9c: c7 05 ac e8 11 00 b0 movl $0x11e8b0,0x11e8ac 10cfa3: e8 11 00 10cfa6: c7 05 b0 e8 11 00 00 movl $0x0,0x11e8b0 10cfad: 00 00 00 10cfb0: c7 05 b4 e8 11 00 ac movl $0x11e8ac,0x11e8b4 10cfb7: e8 11 00 10cfba: c7 05 5c e6 11 00 60 movl $0x11e660,0x11e65c 10cfc1: e6 11 00 10cfc4: c7 05 60 e6 11 00 00 movl $0x0,0x11e660 10cfcb: 00 00 00 10cfce: c7 05 64 e6 11 00 5c movl $0x11e65c,0x11e664 10cfd5: e6 11 00 uint32_t i; _Chain_Initialize_empty( &_User_extensions_List ); _Chain_Initialize_empty( &_User_extensions_Switches_list ); if ( initial_extensions ) { 10cfd8: 85 f6 test %esi,%esi 10cfda: 74 50 je 10d02c <_User_extensions_Handler_initialization+0x9c> extension = (User_extensions_Control *) 10cfdc: 8b 55 08 mov 0x8(%ebp),%edx 10cfdf: 8d 04 52 lea (%edx,%edx,2),%eax 10cfe2: 8d 04 82 lea (%edx,%eax,4),%eax 10cfe5: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx 10cfec: 83 ec 0c sub $0xc,%esp 10cfef: 53 push %ebx 10cff0: e8 43 04 00 00 call 10d438 <_Workspace_Allocate_or_fatal_error> 10cff5: 89 45 ec mov %eax,-0x14(%ebp) _Workspace_Allocate_or_fatal_error( number_of_extensions * sizeof( User_extensions_Control ) ); memset ( 10cff8: 31 c0 xor %eax,%eax 10cffa: 8b 7d ec mov -0x14(%ebp),%edi 10cffd: 89 d9 mov %ebx,%ecx 10cfff: f3 aa rep stos %al,%es:(%edi) extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10d001: 83 c4 10 add $0x10,%esp 10d004: 8b 45 08 mov 0x8(%ebp),%eax 10d007: 85 c0 test %eax,%eax 10d009: 74 21 je 10d02c <_User_extensions_Handler_initialization+0x9c><== NEVER TAKEN 10d00b: 31 db xor %ebx,%ebx 10d00d: 8d 76 00 lea 0x0(%esi),%esi _User_extensions_Add_set (extension, &initial_extensions[i]); 10d010: 83 ec 08 sub $0x8,%esp 10d013: 56 push %esi 10d014: ff 75 ec pushl -0x14(%ebp) 10d017: e8 ac 28 00 00 call 10f8c8 <_User_extensions_Add_set> extension++; 10d01c: 83 45 ec 34 addl $0x34,-0x14(%ebp) extension, 0, number_of_extensions * sizeof( User_extensions_Control ) ); for ( i = 0 ; i < number_of_extensions ; i++ ) { 10d020: 43 inc %ebx 10d021: 83 c6 20 add $0x20,%esi 10d024: 83 c4 10 add $0x10,%esp 10d027: 39 5d 08 cmp %ebx,0x8(%ebp) 10d02a: 77 e4 ja 10d010 <_User_extensions_Handler_initialization+0x80> _User_extensions_Add_set (extension, &initial_extensions[i]); extension++; } } } 10d02c: 8d 65 f4 lea -0xc(%ebp),%esp 10d02f: 5b pop %ebx 10d030: 5e pop %esi 10d031: 5f pop %edi 10d032: c9 leave 10d033: c3 ret =============================================================================== 0010ec54 <_User_extensions_Remove_set>: */ void _User_extensions_Remove_set ( User_extensions_Control *the_extension ) { 10ec54: 55 push %ebp 10ec55: 89 e5 mov %esp,%ebp 10ec57: 53 push %ebx 10ec58: 83 ec 10 sub $0x10,%esp 10ec5b: 8b 5d 08 mov 0x8(%ebp),%ebx _Chain_Extract( &the_extension->Node ); 10ec5e: 53 push %ebx 10ec5f: e8 18 21 00 00 call 110d7c <_Chain_Extract> /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) 10ec64: 83 c4 10 add $0x10,%esp 10ec67: 8b 43 24 mov 0x24(%ebx),%eax 10ec6a: 85 c0 test %eax,%eax 10ec6c: 74 12 je 10ec80 <_User_extensions_Remove_set+0x2c><== ALWAYS TAKEN _Chain_Extract( &the_extension->Switch.Node ); 10ec6e: 8d 43 08 lea 0x8(%ebx),%eax <== NOT EXECUTED 10ec71: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } 10ec74: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ec77: 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 ); 10ec78: e9 ff 20 00 00 jmp 110d7c <_Chain_Extract> <== NOT EXECUTED 10ec7d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } 10ec80: 8b 5d fc mov -0x4(%ebp),%ebx 10ec83: c9 leave 10ec84: c3 ret =============================================================================== 0010d034 <_User_extensions_Thread_begin>: */ void _User_extensions_Thread_begin ( Thread_Control *executing ) { 10d034: 55 push %ebp 10d035: 89 e5 mov %esp,%ebp 10d037: 56 push %esi 10d038: 53 push %ebx 10d039: 8b 75 08 mov 0x8(%ebp),%esi Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; 10d03c: 8b 1d ac e8 11 00 mov 0x11e8ac,%ebx !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d042: 81 fb b0 e8 11 00 cmp $0x11e8b0,%ebx 10d048: 74 1c je 10d066 <_User_extensions_Thread_begin+0x32><== NEVER TAKEN 10d04a: 66 90 xchg %ax,%ax the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) 10d04c: 8b 43 28 mov 0x28(%ebx),%eax 10d04f: 85 c0 test %eax,%eax 10d051: 74 09 je 10d05c <_User_extensions_Thread_begin+0x28> (*the_extension->Callouts.thread_begin)( executing ); 10d053: 83 ec 0c sub $0xc,%esp 10d056: 56 push %esi 10d057: ff d0 call *%eax 10d059: 83 c4 10 add $0x10,%esp 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 ) { 10d05c: 8b 1b mov (%ebx),%ebx { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d05e: 81 fb b0 e8 11 00 cmp $0x11e8b0,%ebx 10d064: 75 e6 jne 10d04c <_User_extensions_Thread_begin+0x18> the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_begin != NULL ) (*the_extension->Callouts.thread_begin)( executing ); } } 10d066: 8d 65 f8 lea -0x8(%ebp),%esp 10d069: 5b pop %ebx 10d06a: 5e pop %esi 10d06b: c9 leave 10d06c: c3 ret =============================================================================== 0010d0f4 <_User_extensions_Thread_create>: */ bool _User_extensions_Thread_create ( Thread_Control *the_thread ) { 10d0f4: 55 push %ebp 10d0f5: 89 e5 mov %esp,%ebp 10d0f7: 56 push %esi 10d0f8: 53 push %ebx 10d0f9: 8b 75 08 mov 0x8(%ebp),%esi Chain_Node *the_node; User_extensions_Control *the_extension; bool status; for ( the_node = _User_extensions_List.first ; 10d0fc: 8b 1d ac e8 11 00 mov 0x11e8ac,%ebx !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d102: 81 fb b0 e8 11 00 cmp $0x11e8b0,%ebx 10d108: 74 26 je 10d130 <_User_extensions_Thread_create+0x3c><== NEVER TAKEN 10d10a: 66 90 xchg %ax,%ax the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_create != NULL ) { 10d10c: 8b 43 14 mov 0x14(%ebx),%eax 10d10f: 85 c0 test %eax,%eax 10d111: 74 13 je 10d126 <_User_extensions_Thread_create+0x32> status = (*the_extension->Callouts.thread_create)( 10d113: 83 ec 08 sub $0x8,%esp 10d116: 56 push %esi 10d117: ff 35 1c e7 11 00 pushl 0x11e71c 10d11d: ff d0 call *%eax _Thread_Executing, the_thread ); if ( !status ) 10d11f: 83 c4 10 add $0x10,%esp 10d122: 84 c0 test %al,%al 10d124: 74 0c je 10d132 <_User_extensions_Thread_create+0x3e><== NEVER TAKEN 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 ) { 10d126: 8b 1b mov (%ebx),%ebx 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 ) ; 10d128: 81 fb b0 e8 11 00 cmp $0x11e8b0,%ebx 10d12e: 75 dc jne 10d10c <_User_extensions_Thread_create+0x18> 10d130: b0 01 mov $0x1,%al return FALSE; } } return TRUE; } 10d132: 8d 65 f8 lea -0x8(%ebp),%esp 10d135: 5b pop %ebx 10d136: 5e pop %esi 10d137: c9 leave 10d138: c3 ret =============================================================================== 0010d13c <_User_extensions_Thread_delete>: */ void _User_extensions_Thread_delete ( Thread_Control *the_thread ) { 10d13c: 55 push %ebp 10d13d: 89 e5 mov %esp,%ebp 10d13f: 56 push %esi 10d140: 53 push %ebx 10d141: 8b 75 08 mov 0x8(%ebp),%esi Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10d144: 8b 1d b4 e8 11 00 mov 0x11e8b4,%ebx !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d14a: 81 fb ac e8 11 00 cmp $0x11e8ac,%ebx 10d150: 74 23 je 10d175 <_User_extensions_Thread_delete+0x39><== NEVER TAKEN 10d152: 66 90 xchg %ax,%ax the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_delete != NULL ) 10d154: 8b 43 20 mov 0x20(%ebx),%eax 10d157: 85 c0 test %eax,%eax 10d159: 74 0f je 10d16a <_User_extensions_Thread_delete+0x2e> (*the_extension->Callouts.thread_delete)( 10d15b: 83 ec 08 sub $0x8,%esp 10d15e: 56 push %esi 10d15f: ff 35 1c e7 11 00 pushl 0x11e71c 10d165: ff d0 call *%eax 10d167: 83 c4 10 add $0x10,%esp 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 ) { 10d16a: 8b 5b 04 mov 0x4(%ebx),%ebx { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d16d: 81 fb ac e8 11 00 cmp $0x11e8ac,%ebx 10d173: 75 df jne 10d154 <_User_extensions_Thread_delete+0x18> (*the_extension->Callouts.thread_delete)( _Thread_Executing, the_thread ); } } 10d175: 8d 65 f8 lea -0x8(%ebp),%esp 10d178: 5b pop %ebx 10d179: 5e pop %esi 10d17a: c9 leave 10d17b: c3 ret =============================================================================== 0010d070 <_User_extensions_Thread_exitted>: */ void _User_extensions_Thread_exitted ( Thread_Control *executing ) { 10d070: 55 push %ebp 10d071: 89 e5 mov %esp,%ebp 10d073: 56 push %esi 10d074: 53 push %ebx 10d075: 8b 75 08 mov 0x8(%ebp),%esi Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; 10d078: 8b 1d b4 e8 11 00 mov 0x11e8b4,%ebx !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d07e: 81 fb ac e8 11 00 cmp $0x11e8ac,%ebx 10d084: 74 1d je 10d0a3 <_User_extensions_Thread_exitted+0x33><== NEVER TAKEN 10d086: 66 90 xchg %ax,%ax the_node = the_node->previous ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) 10d088: 8b 43 2c mov 0x2c(%ebx),%eax 10d08b: 85 c0 test %eax,%eax 10d08d: 74 09 je 10d098 <_User_extensions_Thread_exitted+0x28> (*the_extension->Callouts.thread_exitted)( executing ); 10d08f: 83 ec 0c sub $0xc,%esp 10d092: 56 push %esi 10d093: ff d0 call *%eax 10d095: 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 ) { 10d098: 8b 5b 04 mov 0x4(%ebx),%ebx { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.last ; !_Chain_Is_head( &_User_extensions_List, the_node ) ; 10d09b: 81 fb ac e8 11 00 cmp $0x11e8ac,%ebx 10d0a1: 75 e5 jne 10d088 <_User_extensions_Thread_exitted+0x18> the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_exitted != NULL ) (*the_extension->Callouts.thread_exitted)( executing ); } } 10d0a3: 8d 65 f8 lea -0x8(%ebp),%esp 10d0a6: 5b pop %ebx 10d0a7: 5e pop %esi 10d0a8: c9 leave 10d0a9: c3 ret =============================================================================== 0010dc48 <_User_extensions_Thread_restart>: */ void _User_extensions_Thread_restart ( Thread_Control *the_thread ) { 10dc48: 55 push %ebp 10dc49: 89 e5 mov %esp,%ebp 10dc4b: 56 push %esi 10dc4c: 53 push %ebx 10dc4d: 8b 75 08 mov 0x8(%ebp),%esi Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; 10dc50: 8b 1d 0c 19 12 00 mov 0x12190c,%ebx !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10dc56: 81 fb 10 19 12 00 cmp $0x121910,%ebx 10dc5c: 74 22 je 10dc80 <_User_extensions_Thread_restart+0x38><== NEVER TAKEN 10dc5e: 66 90 xchg %ax,%ax the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_restart != NULL ) 10dc60: 8b 43 1c mov 0x1c(%ebx),%eax 10dc63: 85 c0 test %eax,%eax 10dc65: 74 0f je 10dc76 <_User_extensions_Thread_restart+0x2e> (*the_extension->Callouts.thread_restart)( 10dc67: 83 ec 08 sub $0x8,%esp 10dc6a: 56 push %esi 10dc6b: ff 35 7c 17 12 00 pushl 0x12177c 10dc71: ff d0 call *%eax 10dc73: 83 c4 10 add $0x10,%esp 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 ) { 10dc76: 8b 1b mov (%ebx),%ebx { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10dc78: 81 fb 10 19 12 00 cmp $0x121910,%ebx 10dc7e: 75 e0 jne 10dc60 <_User_extensions_Thread_restart+0x18> (*the_extension->Callouts.thread_restart)( _Thread_Executing, the_thread ); } } 10dc80: 8d 65 f8 lea -0x8(%ebp),%esp 10dc83: 5b pop %ebx 10dc84: 5e pop %esi 10dc85: c9 leave 10dc86: c3 ret =============================================================================== 0010d17c <_User_extensions_Thread_start>: */ void _User_extensions_Thread_start ( Thread_Control *the_thread ) { 10d17c: 55 push %ebp 10d17d: 89 e5 mov %esp,%ebp 10d17f: 56 push %esi 10d180: 53 push %ebx 10d181: 8b 75 08 mov 0x8(%ebp),%esi Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; 10d184: 8b 1d ac e8 11 00 mov 0x11e8ac,%ebx !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d18a: 81 fb b0 e8 11 00 cmp $0x11e8b0,%ebx 10d190: 74 22 je 10d1b4 <_User_extensions_Thread_start+0x38><== NEVER TAKEN 10d192: 66 90 xchg %ax,%ax the_node = the_node->next ) { the_extension = (User_extensions_Control *) the_node; if ( the_extension->Callouts.thread_start != NULL ) 10d194: 8b 43 18 mov 0x18(%ebx),%eax 10d197: 85 c0 test %eax,%eax 10d199: 74 0f je 10d1aa <_User_extensions_Thread_start+0x2e> (*the_extension->Callouts.thread_start)( 10d19b: 83 ec 08 sub $0x8,%esp 10d19e: 56 push %esi 10d19f: ff 35 1c e7 11 00 pushl 0x11e71c 10d1a5: ff d0 call *%eax 10d1a7: 83 c4 10 add $0x10,%esp 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 ) { 10d1aa: 8b 1b mov (%ebx),%ebx { Chain_Node *the_node; User_extensions_Control *the_extension; for ( the_node = _User_extensions_List.first ; !_Chain_Is_tail( &_User_extensions_List, the_node ) ; 10d1ac: 81 fb b0 e8 11 00 cmp $0x11e8b0,%ebx 10d1b2: 75 e0 jne 10d194 <_User_extensions_Thread_start+0x18> (*the_extension->Callouts.thread_start)( _Thread_Executing, the_thread ); } } 10d1b4: 8d 65 f8 lea -0x8(%ebp),%esp 10d1b7: 5b pop %ebx 10d1b8: 5e pop %esi 10d1b9: c9 leave 10d1ba: c3 ret =============================================================================== 0010d1bc <_User_extensions_Thread_switch>: */ void _User_extensions_Thread_switch ( Thread_Control *executing, Thread_Control *heir ) { 10d1bc: 55 push %ebp 10d1bd: 89 e5 mov %esp,%ebp 10d1bf: 57 push %edi 10d1c0: 56 push %esi 10d1c1: 53 push %ebx 10d1c2: 83 ec 0c sub $0xc,%esp 10d1c5: 8b 7d 08 mov 0x8(%ebp),%edi 10d1c8: 8b 75 0c mov 0xc(%ebp),%esi Chain_Node *the_node; User_extensions_Switch_control *the_extension_switch; for ( the_node = _User_extensions_Switches_list.first ; 10d1cb: 8b 1d 5c e6 11 00 mov 0x11e65c,%ebx !_Chain_Is_tail( &_User_extensions_Switches_list, the_node ) ; 10d1d1: 81 fb 60 e6 11 00 cmp $0x11e660,%ebx 10d1d7: 74 18 je 10d1f1 <_User_extensions_Thread_switch+0x35><== NEVER TAKEN 10d1d9: 8d 76 00 lea 0x0(%esi),%esi the_node = the_node->next ) { the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); 10d1dc: 83 ec 08 sub $0x8,%esp 10d1df: 56 push %esi 10d1e0: 57 push %edi 10d1e1: ff 53 08 call *0x8(%ebx) 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 ) { 10d1e4: 8b 1b mov (%ebx),%ebx { 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 ) ; 10d1e6: 83 c4 10 add $0x10,%esp 10d1e9: 81 fb 60 e6 11 00 cmp $0x11e660,%ebx 10d1ef: 75 eb jne 10d1dc <_User_extensions_Thread_switch+0x20> the_extension_switch = (User_extensions_Switch_control *) the_node; (*the_extension_switch->thread_switch)( executing, heir ); } } 10d1f1: 8d 65 f4 lea -0xc(%ebp),%esp 10d1f4: 5b pop %ebx 10d1f5: 5e pop %esi 10d1f6: 5f pop %edi 10d1f7: c9 leave 10d1f8: c3 ret =============================================================================== 0010e9a4 <_Watchdog_Adjust>: void _Watchdog_Adjust( Chain_Control *header, Watchdog_Adjust_directions direction, Watchdog_Interval units ) { 10e9a4: 55 push %ebp 10e9a5: 89 e5 mov %esp,%ebp 10e9a7: 57 push %edi 10e9a8: 56 push %esi 10e9a9: 53 push %ebx 10e9aa: 83 ec 0c sub $0xc,%esp 10e9ad: 8b 7d 08 mov 0x8(%ebp),%edi 10e9b0: 8b 4d 0c mov 0xc(%ebp),%ecx 10e9b3: 8b 75 10 mov 0x10(%ebp),%esi ISR_Level level; _ISR_Disable( level ); 10e9b6: 9c pushf 10e9b7: fa cli 10e9b8: 5a pop %edx * 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( 10e9b9: 8b 07 mov (%edi),%eax * @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 10e9bb: 8d 5f 04 lea 0x4(%edi),%ebx 10e9be: 89 5d f0 mov %ebx,-0x10(%ebp) * hence the compiler must not assume *header to remain * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { 10e9c1: 39 d8 cmp %ebx,%eax 10e9c3: 74 3f je 10ea04 <_Watchdog_Adjust+0x60> switch ( direction ) { 10e9c5: 85 c9 test %ecx,%ecx 10e9c7: 75 47 jne 10ea10 <_Watchdog_Adjust+0x6c> case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10e9c9: 85 f6 test %esi,%esi 10e9cb: 74 37 je 10ea04 <_Watchdog_Adjust+0x60> <== NEVER TAKEN if ( units < _Watchdog_First( header )->delta_interval ) { 10e9cd: 8b 58 10 mov 0x10(%eax),%ebx 10e9d0: 39 de cmp %ebx,%esi 10e9d2: 73 0f jae 10e9e3 <_Watchdog_Adjust+0x3f> <== ALWAYS TAKEN 10e9d4: eb 42 jmp 10ea18 <_Watchdog_Adjust+0x74> <== NOT EXECUTED 10e9d6: 66 90 xchg %ax,%ax <== NOT EXECUTED switch ( direction ) { case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; break; case WATCHDOG_FORWARD: while ( units ) { 10e9d8: 29 de sub %ebx,%esi 10e9da: 74 28 je 10ea04 <_Watchdog_Adjust+0x60> <== NEVER TAKEN if ( units < _Watchdog_First( header )->delta_interval ) { 10e9dc: 8b 58 10 mov 0x10(%eax),%ebx 10e9df: 39 f3 cmp %esi,%ebx 10e9e1: 77 35 ja 10ea18 <_Watchdog_Adjust+0x74> _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 1; 10e9e3: c7 40 10 01 00 00 00 movl $0x1,0x10(%eax) _ISR_Enable( level ); 10e9ea: 52 push %edx 10e9eb: 9d popf _Watchdog_Tickle( header ); 10e9ec: 83 ec 0c sub $0xc,%esp 10e9ef: 57 push %edi 10e9f0: e8 c7 01 00 00 call 10ebbc <_Watchdog_Tickle> _ISR_Disable( level ); 10e9f5: 9c pushf 10e9f6: fa cli 10e9f7: 5a pop %edx * 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( 10e9f8: 8b 07 mov (%edi),%eax if ( _Chain_Is_empty( header ) ) 10e9fa: 83 c4 10 add $0x10,%esp 10e9fd: 39 45 f0 cmp %eax,-0x10(%ebp) 10ea00: 75 d6 jne 10e9d8 <_Watchdog_Adjust+0x34> 10ea02: 66 90 xchg %ax,%ax } break; } } _ISR_Enable( level ); 10ea04: 52 push %edx 10ea05: 9d popf } 10ea06: 8d 65 f4 lea -0xc(%ebp),%esp 10ea09: 5b pop %ebx 10ea0a: 5e pop %esi 10ea0b: 5f pop %edi 10ea0c: c9 leave 10ea0d: c3 ret 10ea0e: 66 90 xchg %ax,%ax * unmodified across that call. * * Till Straumann, 7/2003 */ if ( !_Chain_Is_empty( header ) ) { switch ( direction ) { 10ea10: 49 dec %ecx 10ea11: 75 f1 jne 10ea04 <_Watchdog_Adjust+0x60> <== NEVER TAKEN case WATCHDOG_BACKWARD: _Watchdog_First( header )->delta_interval += units; 10ea13: 01 70 10 add %esi,0x10(%eax) 10ea16: eb ec jmp 10ea04 <_Watchdog_Adjust+0x60> break; case WATCHDOG_FORWARD: while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { _Watchdog_First( header )->delta_interval -= units; 10ea18: 29 f3 sub %esi,%ebx 10ea1a: 89 58 10 mov %ebx,0x10(%eax) 10ea1d: eb e5 jmp 10ea04 <_Watchdog_Adjust+0x60> =============================================================================== 00118658 <_Watchdog_Adjust_to_chain>: Chain_Control *header, Watchdog_Interval units_arg, Chain_Control *to_fire ) { 118658: 55 push %ebp 118659: 89 e5 mov %esp,%ebp 11865b: 57 push %edi 11865c: 56 push %esi 11865d: 53 push %ebx 11865e: 83 ec 0c sub $0xc,%esp 118661: 8b 5d 08 mov 0x8(%ebp),%ebx 118664: 8b 7d 10 mov 0x10(%ebp),%edi Watchdog_Interval units = units_arg; ISR_Level level; Chain_Node *node; if ( !units ) { 118667: 8b 45 0c mov 0xc(%ebp),%eax 11866a: 85 c0 test %eax,%eax 11866c: 74 6a je 1186d8 <_Watchdog_Adjust_to_chain+0x80> return; } _ISR_Disable( level ); 11866e: 9c pushf 11866f: fa cli 118670: 8f 45 ec popl -0x14(%ebp) 118673: 8b 13 mov (%ebx),%edx * @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 118675: 8d 4b 04 lea 0x4(%ebx),%ecx if ( !_Chain_Is_empty( header ) ) { 118678: 39 ca cmp %ecx,%edx 11867a: 74 58 je 1186d4 <_Watchdog_Adjust_to_chain+0x7c> 11867c: 8b 72 10 mov 0x10(%edx),%esi 11867f: 8d 47 04 lea 0x4(%edi),%eax 118682: 89 45 f0 mov %eax,-0x10(%ebp) 118685: 8b 45 0c mov 0xc(%ebp),%eax 118688: 89 45 e8 mov %eax,-0x18(%ebp) 11868b: 90 nop while ( units ) { if ( units < _Watchdog_First( header )->delta_interval ) { 11868c: 3b 75 e8 cmp -0x18(%ebp),%esi 11868f: 77 3c ja 1186cd <_Watchdog_Adjust_to_chain+0x75> _Watchdog_First( header )->delta_interval -= units; break; } else { units -= _Watchdog_First( header )->delta_interval; _Watchdog_First( header )->delta_interval = 0; 118691: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) 118698: eb 2b jmp 1186c5 <_Watchdog_Adjust_to_chain+0x6d> 11869a: 66 90 xchg %ax,%ax 11869c: 8b 02 mov (%edx),%eax 11869e: 89 03 mov %eax,(%ebx) 1186a0: 89 58 04 mov %ebx,0x4(%eax) 1186a3: 8b 45 f0 mov -0x10(%ebp),%eax 1186a6: 89 02 mov %eax,(%edx) 1186a8: 8b 47 08 mov 0x8(%edi),%eax 1186ab: 89 57 08 mov %edx,0x8(%edi) 1186ae: 89 10 mov %edx,(%eax) 1186b0: 89 42 04 mov %eax,0x4(%edx) do { node = _Chain_Get_unprotected( header ); _Chain_Append_unprotected( to_fire, node ); _ISR_Flash( level ); 1186b3: ff 75 ec pushl -0x14(%ebp) 1186b6: 9d popf 1186b7: fa cli * 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( 1186b8: 8b 13 mov (%ebx),%edx } while ( !_Chain_Is_empty( header ) && _Watchdog_First( header )->delta_interval == 0 ); 1186ba: 39 d1 cmp %edx,%ecx 1186bc: 74 16 je 1186d4 <_Watchdog_Adjust_to_chain+0x7c> 1186be: 8b 42 10 mov 0x10(%edx),%eax 1186c1: 85 c0 test %eax,%eax 1186c3: 75 1b jne 1186e0 <_Watchdog_Adjust_to_chain+0x88> 1186c5: 39 d1 cmp %edx,%ecx 1186c7: 75 d3 jne 11869c <_Watchdog_Adjust_to_chain+0x44><== ALWAYS TAKEN 1186c9: 31 d2 xor %edx,%edx <== NOT EXECUTED 1186cb: eb d6 jmp 1186a3 <_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; 1186cd: 2b 75 e8 sub -0x18(%ebp),%esi 1186d0: 89 72 10 mov %esi,0x10(%edx) 1186d3: 90 nop break; } } } _ISR_Enable( level ); 1186d4: ff 75 ec pushl -0x14(%ebp) 1186d7: 9d popf } 1186d8: 83 c4 0c add $0xc,%esp 1186db: 5b pop %ebx 1186dc: 5e pop %esi 1186dd: 5f pop %edi 1186de: c9 leave 1186df: c3 ret return; } _ISR_Disable( level ); if ( !_Chain_Is_empty( header ) ) { while ( units ) { 1186e0: 29 75 e8 sub %esi,-0x18(%ebp) 1186e3: 74 ef je 1186d4 <_Watchdog_Adjust_to_chain+0x7c><== ALWAYS TAKEN 1186e5: 89 c6 mov %eax,%esi <== NOT EXECUTED 1186e7: eb a3 jmp 11868c <_Watchdog_Adjust_to_chain+0x34><== NOT EXECUTED =============================================================================== 0010d1fc <_Watchdog_Insert>: void _Watchdog_Insert( Chain_Control *header, Watchdog_Control *the_watchdog ) { 10d1fc: 55 push %ebp 10d1fd: 89 e5 mov %esp,%ebp 10d1ff: 57 push %edi 10d200: 56 push %esi 10d201: 53 push %ebx 10d202: 83 ec 04 sub $0x4,%esp 10d205: 8b 75 0c mov 0xc(%ebp),%esi Watchdog_Control *after; uint32_t insert_isr_nest_level; Watchdog_Interval delta_interval; insert_isr_nest_level = _ISR_Nest_level; 10d208: 8b 3d f8 e6 11 00 mov 0x11e6f8,%edi _ISR_Disable( level ); 10d20e: 9c pushf 10d20f: fa cli 10d210: 8f 45 f0 popl -0x10(%ebp) /* * 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 ) { 10d213: 8b 46 08 mov 0x8(%esi),%eax 10d216: 85 c0 test %eax,%eax 10d218: 75 72 jne 10d28c <_Watchdog_Insert+0x90> <== NEVER TAKEN _ISR_Enable( level ); return; } the_watchdog->state = WATCHDOG_BEING_INSERTED; 10d21a: c7 46 08 01 00 00 00 movl $0x1,0x8(%esi) _Watchdog_Sync_count++; 10d221: a1 c0 e7 11 00 mov 0x11e7c0,%eax 10d226: 40 inc %eax 10d227: a3 c0 e7 11 00 mov %eax,0x11e7c0 restart: delta_interval = the_watchdog->initial; 10d22c: 8b 5e 0c mov 0xc(%esi),%ebx * cache *header!! * * Till Straumann, 7/2003 (gcc-3.2.2 -O4 on powerpc) * */ for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ; 10d22f: 8b 45 08 mov 0x8(%ebp),%eax 10d232: 8b 08 mov (%eax),%ecx ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10d234: 85 db test %ebx,%ebx 10d236: 74 65 je 10d29d <_Watchdog_Insert+0xa1> <== NEVER TAKEN 10d238: 8b 01 mov (%ecx),%eax 10d23a: 85 c0 test %eax,%eax 10d23c: 74 5f je 10d29d <_Watchdog_Insert+0xa1> break; if ( delta_interval < after->delta_interval ) { 10d23e: 8b 51 10 mov 0x10(%ecx),%edx 10d241: 39 d3 cmp %edx,%ebx 10d243: 73 21 jae 10d266 <_Watchdog_Insert+0x6a> 10d245: eb 51 jmp 10d298 <_Watchdog_Insert+0x9c> 10d247: 90 nop if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { goto exit_insert; } if ( _Watchdog_Sync_level > insert_isr_nest_level ) { 10d248: a1 18 e7 11 00 mov 0x11e718,%eax 10d24d: 39 c7 cmp %eax,%edi 10d24f: 72 6f jb 10d2c0 <_Watchdog_Insert+0xc4> if ( delta_interval < after->delta_interval ) { after->delta_interval -= delta_interval; break; } delta_interval -= after->delta_interval; 10d251: 29 d3 sub %edx,%ebx ); #ifdef __cplusplus } #endif 10d253: 8b 09 mov (%ecx),%ecx */ for ( after = (Watchdog_Control *) ((volatile Chain_Control *)header)->first ; ; after = _Watchdog_Next( after ) ) { if ( delta_interval == 0 || !_Watchdog_Next( after ) ) 10d255: 85 db test %ebx,%ebx 10d257: 74 44 je 10d29d <_Watchdog_Insert+0xa1> 10d259: 8b 11 mov (%ecx),%edx 10d25b: 85 d2 test %edx,%edx 10d25d: 74 3e je 10d29d <_Watchdog_Insert+0xa1> break; if ( delta_interval < after->delta_interval ) { 10d25f: 8b 51 10 mov 0x10(%ecx),%edx 10d262: 39 da cmp %ebx,%edx 10d264: 77 32 ja 10d298 <_Watchdog_Insert+0x9c> * 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 ); 10d266: ff 75 f0 pushl -0x10(%ebp) 10d269: 9d popf 10d26a: fa cli if ( the_watchdog->state != WATCHDOG_BEING_INSERTED ) { 10d26b: 83 7e 08 01 cmpl $0x1,0x8(%esi) 10d26f: 74 d7 je 10d248 <_Watchdog_Insert+0x4c> <== ALWAYS TAKEN _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; 10d271: 89 3d 18 e7 11 00 mov %edi,0x11e718 _Watchdog_Sync_count--; 10d277: a1 c0 e7 11 00 mov 0x11e7c0,%eax 10d27c: 48 dec %eax 10d27d: a3 c0 e7 11 00 mov %eax,0x11e7c0 _ISR_Enable( level ); 10d282: ff 75 f0 pushl -0x10(%ebp) 10d285: 9d popf } 10d286: 58 pop %eax 10d287: 5b pop %ebx 10d288: 5e pop %esi 10d289: 5f pop %edi 10d28a: c9 leave 10d28b: c3 ret * 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 ); 10d28c: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 10d28f: 9d popf <== NOT EXECUTED exit_insert: _Watchdog_Sync_level = insert_isr_nest_level; _Watchdog_Sync_count--; _ISR_Enable( level ); } 10d290: 58 pop %eax <== NOT EXECUTED 10d291: 5b pop %ebx <== NOT EXECUTED 10d292: 5e pop %esi <== NOT EXECUTED 10d293: 5f pop %edi <== NOT EXECUTED 10d294: c9 leave <== NOT EXECUTED 10d295: c3 ret <== NOT EXECUTED 10d296: 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; 10d298: 29 da sub %ebx,%edx 10d29a: 89 51 10 mov %edx,0x10(%ecx) * @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( 10d29d: c7 46 08 02 00 00 00 movl $0x2,0x8(%esi) } } _Watchdog_Activate( the_watchdog ); the_watchdog->delta_interval = delta_interval; 10d2a4: 89 5e 10 mov %ebx,0x10(%esi) _Chain_Insert_unprotected( after->Node.previous, &the_watchdog->Node ); 10d2a7: 8b 41 04 mov 0x4(%ecx),%eax 10d2aa: 89 46 04 mov %eax,0x4(%esi) 10d2ad: 8b 10 mov (%eax),%edx 10d2af: 89 30 mov %esi,(%eax) 10d2b1: 89 16 mov %edx,(%esi) 10d2b3: 89 72 04 mov %esi,0x4(%edx) the_watchdog->start_time = _Watchdog_Ticks_since_boot; 10d2b6: a1 c4 e7 11 00 mov 0x11e7c4,%eax 10d2bb: 89 46 14 mov %eax,0x14(%esi) 10d2be: eb b1 jmp 10d271 <_Watchdog_Insert+0x75> 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; 10d2c0: 89 3d 18 e7 11 00 mov %edi,0x11e718 10d2c6: e9 61 ff ff ff jmp 10d22c <_Watchdog_Insert+0x30> =============================================================================== 0010d32c <_Watchdog_Remove>: */ Watchdog_States _Watchdog_Remove( Watchdog_Control *the_watchdog ) { 10d32c: 55 push %ebp 10d32d: 89 e5 mov %esp,%ebp 10d32f: 56 push %esi 10d330: 53 push %ebx 10d331: 8b 4d 08 mov 0x8(%ebp),%ecx ISR_Level level; Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); 10d334: 9c pushf 10d335: fa cli 10d336: 5e pop %esi previous_state = the_watchdog->state; 10d337: 8b 59 08 mov 0x8(%ecx),%ebx switch ( previous_state ) { 10d33a: 83 fb 01 cmp $0x1,%ebx 10d33d: 74 4d je 10d38c <_Watchdog_Remove+0x60> <== NEVER TAKEN 10d33f: 73 13 jae 10d354 <_Watchdog_Remove+0x28> _Watchdog_Sync_level = _ISR_Nest_level; _Chain_Extract_unprotected( &the_watchdog->Node ); break; } the_watchdog->stop_time = _Watchdog_Ticks_since_boot; 10d341: a1 c4 e7 11 00 mov 0x11e7c4,%eax 10d346: 89 41 18 mov %eax,0x18(%ecx) _ISR_Enable( level ); 10d349: 56 push %esi 10d34a: 9d popf return( previous_state ); } 10d34b: 89 d8 mov %ebx,%eax 10d34d: 5b pop %ebx 10d34e: 5e pop %esi 10d34f: c9 leave 10d350: c3 ret 10d351: 8d 76 00 lea 0x0(%esi),%esi Watchdog_States previous_state; Watchdog_Control *next_watchdog; _ISR_Disable( level ); previous_state = the_watchdog->state; switch ( previous_state ) { 10d354: 83 fb 03 cmp $0x3,%ebx 10d357: 77 e8 ja 10d341 <_Watchdog_Remove+0x15> <== NEVER TAKEN break; case WATCHDOG_ACTIVE: case WATCHDOG_REMOVE_IT: the_watchdog->state = WATCHDOG_INACTIVE; 10d359: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) ); #ifdef __cplusplus } #endif 10d360: 8b 11 mov (%ecx),%edx next_watchdog = _Watchdog_Next( the_watchdog ); if ( _Watchdog_Next(next_watchdog) ) 10d362: 8b 02 mov (%edx),%eax 10d364: 85 c0 test %eax,%eax 10d366: 74 06 je 10d36e <_Watchdog_Remove+0x42> next_watchdog->delta_interval += the_watchdog->delta_interval; 10d368: 8b 41 10 mov 0x10(%ecx),%eax 10d36b: 01 42 10 add %eax,0x10(%edx) if ( _Watchdog_Sync_count ) 10d36e: a1 c0 e7 11 00 mov 0x11e7c0,%eax 10d373: 85 c0 test %eax,%eax 10d375: 74 0a je 10d381 <_Watchdog_Remove+0x55> <== ALWAYS TAKEN _Watchdog_Sync_level = _ISR_Nest_level; 10d377: a1 f8 e6 11 00 mov 0x11e6f8,%eax <== NOT EXECUTED 10d37c: a3 18 e7 11 00 mov %eax,0x11e718 <== NOT EXECUTED 10d381: 8b 41 04 mov 0x4(%ecx),%eax 10d384: 89 42 04 mov %eax,0x4(%edx) 10d387: 89 10 mov %edx,(%eax) 10d389: eb b6 jmp 10d341 <_Watchdog_Remove+0x15> 10d38b: 90 nop /* * 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; 10d38c: c7 41 08 00 00 00 00 movl $0x0,0x8(%ecx) <== NOT EXECUTED 10d393: eb ac jmp 10d341 <_Watchdog_Remove+0x15> <== NOT EXECUTED =============================================================================== 0010d398 <_Watchdog_Tickle>: */ void _Watchdog_Tickle( Chain_Control *header ) { 10d398: 55 push %ebp 10d399: 89 e5 mov %esp,%ebp 10d39b: 57 push %edi 10d39c: 56 push %esi 10d39d: 53 push %ebx 10d39e: 83 ec 0c sub $0xc,%esp 10d3a1: 8b 7d 08 mov 0x8(%ebp),%edi * 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 ); 10d3a4: 9c pushf 10d3a5: fa cli 10d3a6: 5e pop %esi * 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( 10d3a7: 8b 17 mov (%edi),%edx * @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 10d3a9: 8d 47 04 lea 0x4(%edi),%eax 10d3ac: 89 45 f0 mov %eax,-0x10(%ebp) if ( _Chain_Is_empty( header ) ) 10d3af: 39 c2 cmp %eax,%edx 10d3b1: 74 11 je 10d3c4 <_Watchdog_Tickle+0x2c> 10d3b3: 89 d3 mov %edx,%ebx * 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) { 10d3b5: 8b 42 10 mov 0x10(%edx),%eax 10d3b8: 85 c0 test %eax,%eax 10d3ba: 74 34 je 10d3f0 <_Watchdog_Tickle+0x58> <== NEVER TAKEN the_watchdog->delta_interval--; 10d3bc: 48 dec %eax 10d3bd: 89 42 10 mov %eax,0x10(%edx) if ( the_watchdog->delta_interval != 0 ) 10d3c0: 85 c0 test %eax,%eax 10d3c2: 74 2c je 10d3f0 <_Watchdog_Tickle+0x58> the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); leave: _ISR_Enable(level); 10d3c4: 56 push %esi 10d3c5: 9d popf } 10d3c6: 8d 65 f4 lea -0xc(%ebp),%esp 10d3c9: 5b pop %ebx 10d3ca: 5e pop %esi 10d3cb: 5f pop %edi 10d3cc: c9 leave 10d3cd: c3 ret _ISR_Enable( level ); switch( watchdog_state ) { case WATCHDOG_ACTIVE: (*the_watchdog->routine)( 10d3ce: 83 ec 08 sub $0x8,%esp 10d3d1: ff 73 24 pushl 0x24(%ebx) 10d3d4: ff 73 20 pushl 0x20(%ebx) 10d3d7: ff 53 1c call *0x1c(%ebx) 10d3da: 83 c4 10 add $0x10,%esp case WATCHDOG_REMOVE_IT: break; } _ISR_Disable( level ); 10d3dd: 9c pushf 10d3de: fa cli 10d3df: 5e pop %esi 10d3e0: 8b 07 mov (%edi),%eax the_watchdog = _Watchdog_First( header ); } while ( !_Chain_Is_empty( header ) && (the_watchdog->delta_interval == 0) ); 10d3e2: 39 45 f0 cmp %eax,-0x10(%ebp) 10d3e5: 74 dd je 10d3c4 <_Watchdog_Tickle+0x2c> 10d3e7: 89 c3 mov %eax,%ebx 10d3e9: 8b 40 10 mov 0x10(%eax),%eax 10d3ec: 85 c0 test %eax,%eax 10d3ee: 75 d4 jne 10d3c4 <_Watchdog_Tickle+0x2c> if ( the_watchdog->delta_interval != 0 ) goto leave; } do { watchdog_state = _Watchdog_Remove( the_watchdog ); 10d3f0: 83 ec 0c sub $0xc,%esp 10d3f3: 53 push %ebx 10d3f4: e8 33 ff ff ff call 10d32c <_Watchdog_Remove> _ISR_Enable( level ); 10d3f9: 56 push %esi 10d3fa: 9d popf switch( watchdog_state ) { 10d3fb: 83 c4 10 add $0x10,%esp 10d3fe: 83 f8 02 cmp $0x2,%eax 10d401: 75 da jne 10d3dd <_Watchdog_Tickle+0x45> <== NEVER TAKEN 10d403: eb c9 jmp 10d3ce <_Watchdog_Tickle+0x36> =============================================================================== 0010d460 <_Workspace_Handler_initialization>: */ void _Workspace_Handler_initialization( void *starting_address, size_t size ) { 10d460: 55 push %ebp 10d461: 89 e5 mov %esp,%ebp 10d463: 57 push %edi 10d464: 83 ec 04 sub $0x4,%esp 10d467: 8b 55 08 mov 0x8(%ebp),%edx uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) 10d46a: 85 d2 test %edx,%edx 10d46c: 74 2e je 10d49c <_Workspace_Handler_initialization+0x3c> 10d46e: f6 c2 03 test $0x3,%dl 10d471: 75 29 jne 10d49c <_Workspace_Handler_initialization+0x3c><== NEVER TAKEN INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _Configuration_Table->do_zero_of_workspace ) 10d473: a1 f4 e6 11 00 mov 0x11e6f4,%eax 10d478: 80 78 28 00 cmpb $0x0,0x28(%eax) 10d47c: 75 2a jne 10d4a8 <_Workspace_Handler_initialization+0x48><== NEVER TAKEN memset( starting_address, 0, size ); memory_available = _Heap_Initialize( 10d47e: 6a 04 push $0x4 10d480: ff 75 0c pushl 0xc(%ebp) 10d483: 52 push %edx 10d484: 68 80 e6 11 00 push $0x11e680 10d489: e8 aa de ff ff call 10b338 <_Heap_Initialize> starting_address, size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) 10d48e: 83 c4 10 add $0x10,%esp 10d491: 85 c0 test %eax,%eax 10d493: 74 1e je 10d4b3 <_Workspace_Handler_initialization+0x53><== NEVER TAKEN _Internal_error_Occurred( INTERNAL_ERROR_CORE, TRUE, INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } 10d495: 8b 7d fc mov -0x4(%ebp),%edi 10d498: c9 leave 10d499: c3 ret 10d49a: 66 90 xchg %ax,%ax ) { uint32_t memory_available; if ( !starting_address || !_Addresses_Is_aligned( starting_address ) ) _Internal_error_Occurred( 10d49c: 51 push %ecx 10d49d: 6a 02 push $0x2 10d49f: 6a 01 push $0x1 10d4a1: 6a 00 push $0x0 10d4a3: e8 78 e0 ff ff call 10b520 <_Internal_error_Occurred> TRUE, INTERNAL_ERROR_INVALID_WORKSPACE_ADDRESS ); if ( _Configuration_Table->do_zero_of_workspace ) memset( starting_address, 0, size ); 10d4a8: 31 c0 xor %eax,%eax 10d4aa: 89 d7 mov %edx,%edi <== NOT EXECUTED 10d4ac: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 10d4af: f3 aa rep stos %al,%es:(%edi) <== NOT EXECUTED 10d4b1: eb cb jmp 10d47e <_Workspace_Handler_initialization+0x1e><== NOT EXECUTED size, CPU_HEAP_ALIGNMENT ); if ( memory_available == 0 ) _Internal_error_Occurred( 10d4b3: 52 push %edx <== NOT EXECUTED 10d4b4: 6a 03 push $0x3 <== NOT EXECUTED 10d4b6: 6a 01 push $0x1 <== NOT EXECUTED 10d4b8: 6a 00 push $0x0 <== NOT EXECUTED 10d4ba: e8 61 e0 ff ff call 10b520 <_Internal_error_Occurred><== NOT EXECUTED =============================================================================== 00106ec8 <__assert>: void __assert( const char *file, int line, const char *failedexpr ) { 106ec8: 55 push %ebp <== NOT EXECUTED 106ec9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106ecb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED __assert_func (file, line, NULL, failedexpr); 106ece: ff 75 10 pushl 0x10(%ebp) <== NOT EXECUTED 106ed1: 6a 00 push $0x0 <== NOT EXECUTED 106ed3: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 106ed6: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106ed9: e8 aa ff ff ff call 106e88 <__assert_func> <== NOT EXECUTED 106ede: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 106ee1: c9 leave <== NOT EXECUTED 106ee2: c3 ret <== NOT EXECUTED =============================================================================== 00106e88 <__assert_func>: const char *file, int line, const char *func, const char *failedexpr ) { 106e88: 55 push %ebp <== NOT EXECUTED 106e89: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106e8b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 106e8e: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n", 106e91: 85 c0 test %eax,%eax <== NOT EXECUTED 106e93: 74 27 je 106ebc <__assert_func+0x34> <== NOT EXECUTED 106e95: ba 57 84 11 00 mov $0x118457,%edx <== NOT EXECUTED 106e9a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 106e9d: 50 push %eax <== NOT EXECUTED 106e9e: 52 push %edx <== NOT EXECUTED 106e9f: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 106ea2: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106ea5: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 106ea8: 68 64 84 11 00 push $0x118464 <== NOT EXECUTED 106ead: e8 86 0f 00 00 call 107e38 <== NOT EXECUTED file, line, (func) ? ", function: " : "", (func) ? func : "" ); rtems_fatal_error_occurred(0); 106eb2: 83 c4 14 add $0x14,%esp <== NOT EXECUTED 106eb5: 6a 00 push $0x0 <== NOT EXECUTED 106eb7: e8 c8 3b 00 00 call 10aa84 <== NOT EXECUTED int line, const char *func, const char *failedexpr ) { printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n", 106ebc: ba c6 85 11 00 mov $0x1185c6,%edx <== NOT EXECUTED 106ec1: 89 d0 mov %edx,%eax <== NOT EXECUTED 106ec3: eb d5 jmp 106e9a <__assert_func+0x12> <== NOT EXECUTED =============================================================================== 00119350 <__kill>: #endif #endif int __kill( pid_t pid, int sig ) { 119350: 55 push %ebp <== NOT EXECUTED 119351: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 119353: 31 c0 xor %eax,%eax <== NOT EXECUTED 119355: c9 leave <== NOT EXECUTED 119356: c3 ret <== NOT EXECUTED =============================================================================== 00116774 <_exit>: /* * If the toolset uses init/fini sections, then we need to * run the global destructors now. */ #if defined(__USE_INIT_FINI__) _fini(); 116774: 55 push %ebp 116775: 89 e5 mov %esp,%ebp 116777: 83 ec 08 sub $0x8,%esp 11677a: e8 5e 07 00 00 call 116edd <_fini> * 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(); 11677f: e8 84 ff ff ff call 116708 rtems_shutdown_executive(status); 116784: 83 ec 0c sub $0xc,%esp 116787: ff 75 08 pushl 0x8(%ebp) 11678a: e8 f9 00 00 00 call 116888 11678f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116792: eb fe jmp 116792 <_exit+0x1e> <== NOT EXECUTED =============================================================================== 00119218 <_getpid_r>: #include pid_t _getpid_r( struct _reent *ptr ) { 119218: 55 push %ebp <== NOT EXECUTED 119219: 89 e5 mov %esp,%ebp <== NOT EXECUTED return getpid(); } 11921b: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 119220: c9 leave <== NOT EXECUTED 119221: c3 ret <== NOT EXECUTED =============================================================================== 0010e6a8 <_gettimeofday>: int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { 10e6a8: 55 push %ebp <== NOT EXECUTED 10e6a9: 89 e5 mov %esp,%ebp <== NOT EXECUTED return gettimeofday( tp, tzp ); } 10e6ab: c9 leave <== NOT EXECUTED int _gettimeofday( struct timeval *tp, struct timezone *tzp ) { return gettimeofday( tp, tzp ); 10e6ac: e9 a3 ff ff ff jmp 10e654 <== NOT EXECUTED =============================================================================== 00119348 <_kill_r>: #if defined(RTEMS_NEWLIB) #include int _kill_r( struct _reent *ptr, pid_t pid, int sig ) { 119348: 55 push %ebp <== NOT EXECUTED 119349: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 11934b: 31 c0 xor %eax,%eax <== NOT EXECUTED 11934d: c9 leave <== NOT EXECUTED 11934e: c3 ret <== NOT EXECUTED =============================================================================== 001166dc <_lseek_r>: struct _reent *ptr, int fd, off_t offset, int whence ) { 1166dc: 55 push %ebp <== NOT EXECUTED 1166dd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1166df: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1166e2: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return lseek( fd, offset, whence ); 1166e5: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 1166e8: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 1166eb: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 1166ee: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 1166f1: c9 leave <== NOT EXECUTED int fd, off_t offset, int whence ) { return lseek( fd, offset, whence ); 1166f2: e9 29 ff ff ff jmp 116620 <== NOT EXECUTED =============================================================================== 00107b04 <_open_r>: struct _reent *ptr, const char *buf, int flags, int mode ) { 107b04: 55 push %ebp <== NOT EXECUTED 107b05: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107b07: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 107b0a: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return open( buf, flags, mode ); 107b0d: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 107b10: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 107b13: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 107b16: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 107b19: c9 leave <== NOT EXECUTED const char *buf, int flags, int mode ) { return open( buf, flags, mode ); 107b1a: e9 61 fd ff ff jmp 107880 <== NOT EXECUTED =============================================================================== 00116838 <_read_r>: struct _reent *ptr, int fd, void *buf, size_t nbytes ) { 116838: 55 push %ebp <== NOT EXECUTED 116839: 89 e5 mov %esp,%ebp <== NOT EXECUTED 11683b: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 11683e: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED return read( fd, buf, nbytes ); 116841: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED 116844: 89 45 10 mov %eax,0x10(%ebp) <== NOT EXECUTED 116847: 89 55 0c mov %edx,0xc(%ebp) <== NOT EXECUTED 11684a: 89 4d 08 mov %ecx,0x8(%ebp) <== NOT EXECUTED } 11684d: c9 leave <== NOT EXECUTED int fd, void *buf, size_t nbytes ) { return read( fd, buf, nbytes ); 11684e: e9 41 ff ff ff jmp 116794 <== NOT EXECUTED =============================================================================== 00116854 <_realloc_r>: void *_realloc_r( struct _reent *ignored, void *ptr, size_t size ) { 116854: 55 push %ebp <== NOT EXECUTED 116855: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116857: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED return realloc( ptr, size ); 11685a: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 11685d: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 116860: 89 55 08 mov %edx,0x8(%ebp) <== NOT EXECUTED } 116863: c9 leave <== NOT EXECUTED struct _reent *ignored, void *ptr, size_t size ) { return realloc( ptr, size ); 116864: e9 4f 00 00 00 jmp 1168b8 <== NOT EXECUTED =============================================================================== 0010e4bc : ) { register char *cptr; int length; MSBUMP(calloc_calls, 1); 10e4bc: 55 push %ebp 10e4bd: 89 e5 mov %esp,%ebp 10e4bf: 57 push %edi 10e4c0: 53 push %ebx 10e4c1: 8b 5d 0c mov 0xc(%ebp),%ebx 10e4c4: ff 05 74 e5 11 00 incl 0x11e574 length = nelem * elsize; 10e4ca: 0f af 5d 08 imul 0x8(%ebp),%ebx cptr = malloc( length ); 10e4ce: 83 ec 0c sub $0xc,%esp 10e4d1: 53 push %ebx 10e4d2: e8 01 8e ff ff call 1072d8 10e4d7: 89 c2 mov %eax,%edx if ( cptr ) 10e4d9: 83 c4 10 add $0x10,%esp 10e4dc: 85 c0 test %eax,%eax 10e4de: 74 08 je 10e4e8 <== NEVER TAKEN memset( cptr, '\0', length ); 10e4e0: 31 c0 xor %eax,%eax 10e4e2: 89 d7 mov %edx,%edi 10e4e4: 89 d9 mov %ebx,%ecx 10e4e6: f3 aa rep stos %al,%es:(%edi) MSBUMP(malloc_calls, -1); /* subtract off the malloc */ 10e4e8: ff 0d 64 e5 11 00 decl 0x11e564 return cptr; } 10e4ee: 89 d0 mov %edx,%eax 10e4f0: 8d 65 f8 lea -0x8(%ebp),%esp 10e4f3: 5b pop %ebx 10e4f4: 5f pop %edi 10e4f5: c9 leave 10e4f6: c3 ret =============================================================================== 0010e4f8 : #include int close( int fd ) { 10e4f8: 55 push %ebp 10e4f9: 89 e5 mov %esp,%ebp 10e4fb: 56 push %esi 10e4fc: 53 push %ebx 10e4fd: 8b 55 08 mov 0x8(%ebp),%edx rtems_libio_t *iop; rtems_status_code rc; rtems_libio_check_fd(fd); 10e500: 3b 15 40 a0 11 00 cmp 0x11a040,%edx 10e506: 73 64 jae 10e56c <== NEVER TAKEN iop = rtems_libio_iop(fd); 10e508: 8d 04 52 lea (%edx,%edx,2),%eax 10e50b: 8d 04 82 lea (%edx,%eax,4),%eax 10e50e: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx 10e515: 03 1d d0 e4 11 00 add 0x11e4d0,%ebx rtems_libio_check_is_open(iop); 10e51b: f6 43 0d 01 testb $0x1,0xd(%ebx) 10e51f: 74 4b je 10e56c <== NEVER TAKEN rc = RTEMS_SUCCESSFUL; if ( iop->handlers->close_h ) 10e521: 8b 43 30 mov 0x30(%ebx),%eax 10e524: 8b 40 04 mov 0x4(%eax),%eax 10e527: 85 c0 test %eax,%eax 10e529: 74 3d je 10e568 <== NEVER TAKEN rc = (*iop->handlers->close_h)( iop ); 10e52b: 83 ec 0c sub $0xc,%esp 10e52e: 53 push %ebx 10e52f: ff d0 call *%eax 10e531: 89 c6 mov %eax,%esi 10e533: 83 c4 10 add $0x10,%esp rtems_filesystem_freenode( &iop->pathinfo ); 10e536: 8b 43 18 mov 0x18(%ebx),%eax 10e539: 85 c0 test %eax,%eax 10e53b: 74 13 je 10e550 <== NEVER TAKEN 10e53d: 8b 50 1c mov 0x1c(%eax),%edx 10e540: 85 d2 test %edx,%edx 10e542: 74 0c je 10e550 <== ALWAYS TAKEN 10e544: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e547: 8d 43 10 lea 0x10(%ebx),%eax <== NOT EXECUTED 10e54a: 50 push %eax <== NOT EXECUTED 10e54b: ff d2 call *%edx <== NOT EXECUTED 10e54d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_libio_free( iop ); 10e550: 83 ec 0c sub $0xc,%esp 10e553: 53 push %ebx 10e554: e8 7b 02 00 00 call 10e7d4 10e559: 83 c4 10 add $0x10,%esp return rc; } 10e55c: 89 f0 mov %esi,%eax 10e55e: 8d 65 f8 lea -0x8(%ebp),%esp 10e561: 5b pop %ebx 10e562: 5e pop %esi 10e563: c9 leave 10e564: c3 ret 10e565: 8d 76 00 lea 0x0(%esi),%esi rtems_libio_check_fd(fd); iop = rtems_libio_iop(fd); rtems_libio_check_is_open(iop); rc = RTEMS_SUCCESSFUL; if ( iop->handlers->close_h ) 10e568: 31 f6 xor %esi,%esi 10e56a: eb ca jmp 10e536 <== 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); 10e56c: e8 af 1c 00 00 call 110220 <__errno> <== NOT EXECUTED 10e571: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10e577: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 10e57c: eb de jmp 10e55c <== NOT EXECUTED =============================================================================== 0010fa48 : */ int device_close( rtems_libio_t *iop ) { 10fa48: 55 push %ebp 10fa49: 89 e5 mov %esp,%ebp 10fa4b: 83 ec 1c sub $0x1c,%esp 10fa4e: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_open_close_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 10fa51: 8b 50 2c mov 0x2c(%eax),%edx args.iop = iop; 10fa54: 89 45 f4 mov %eax,-0xc(%ebp) args.flags = 0; 10fa57: c7 45 f8 00 00 00 00 movl $0x0,-0x8(%ebp) args.mode = 0; 10fa5e: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) status = rtems_io_close( 10fa65: 8d 45 f4 lea -0xc(%ebp),%eax 10fa68: 50 push %eax 10fa69: ff 72 54 pushl 0x54(%edx) 10fa6c: ff 72 50 pushl 0x50(%edx) 10fa6f: e8 34 04 00 00 call 10fea8 the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) { 10fa74: 83 c4 10 add $0x10,%esp 10fa77: 85 c0 test %eax,%eax 10fa79: 75 05 jne 10fa80 <== NEVER TAKEN return rtems_deviceio_errno(status); } return 0; } 10fa7b: c9 leave 10fa7c: c3 ret 10fa7d: 8d 76 00 lea 0x0(%esi),%esi the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) { return rtems_deviceio_errno(status); 10fa80: e8 af fe ff ff call 10f934 <== NOT EXECUTED } return 0; } 10fa85: c9 leave <== NOT EXECUTED 10fa86: c3 ret <== NOT EXECUTED =============================================================================== 0010f92c : int device_ftruncate( rtems_libio_t *iop, off_t length ) { 10f92c: 55 push %ebp <== NOT EXECUTED 10f92d: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 10f92f: 31 c0 xor %eax,%eax <== NOT EXECUTED 10f931: c9 leave <== NOT EXECUTED 10f932: c3 ret <== NOT EXECUTED =============================================================================== 0010f960 : int device_ioctl( rtems_libio_t *iop, uint32_t command, void *buffer ) { 10f960: 55 push %ebp <== NOT EXECUTED 10f961: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f963: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10f966: 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; 10f969: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED args.command = command; 10f96c: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f96f: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.buffer = buffer; 10f972: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10f975: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED the_jnode = iop->file_info; 10f978: 8b 52 2c mov 0x2c(%edx),%edx <== NOT EXECUTED status = rtems_io_control( 10f97b: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10f97e: 50 push %eax <== NOT EXECUTED 10f97f: ff 72 54 pushl 0x54(%edx) <== NOT EXECUTED 10f982: ff 72 50 pushl 0x50(%edx) <== NOT EXECUTED 10f985: e8 5e 05 00 00 call 10fee8 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10f98a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f98d: 85 c0 test %eax,%eax <== NOT EXECUTED 10f98f: 75 07 jne 10f998 <== NOT EXECUTED return rtems_deviceio_errno(status); return args.ioctl_return; 10f991: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 10f994: c9 leave <== NOT EXECUTED 10f995: c3 ret <== NOT EXECUTED 10f996: 66 90 xchg %ax,%ax <== NOT EXECUTED the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 10f998: e8 97 ff ff ff call 10f934 <== NOT EXECUTED return args.ioctl_return; } 10f99d: c9 leave <== NOT EXECUTED 10f99e: c3 ret <== NOT EXECUTED =============================================================================== 0010f924 : off_t device_lseek( rtems_libio_t *iop, off_t offset, int whence ) { 10f924: 55 push %ebp <== NOT EXECUTED 10f925: 89 e5 mov %esp,%ebp <== NOT EXECUTED return offset; } 10f927: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10f92a: c9 leave <== NOT EXECUTED 10f92b: c3 ret <== NOT EXECUTED =============================================================================== 0010fa88 : rtems_libio_t *iop, const char *pathname, uint32_t flag, uint32_t mode ) { 10fa88: 55 push %ebp 10fa89: 89 e5 mov %esp,%ebp 10fa8b: 83 ec 1c sub $0x1c,%esp 10fa8e: 8b 45 08 mov 0x8(%ebp),%eax rtems_libio_open_close_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 10fa91: 8b 50 2c mov 0x2c(%eax),%edx args.iop = iop; 10fa94: 89 45 f4 mov %eax,-0xc(%ebp) args.flags = iop->flags; 10fa97: 8b 40 0c mov 0xc(%eax),%eax 10fa9a: 89 45 f8 mov %eax,-0x8(%ebp) args.mode = mode; 10fa9d: 8b 45 14 mov 0x14(%ebp),%eax 10faa0: 89 45 fc mov %eax,-0x4(%ebp) status = rtems_io_open( 10faa3: 8d 45 f4 lea -0xc(%ebp),%eax 10faa6: 50 push %eax 10faa7: ff 72 54 pushl 0x54(%edx) 10faaa: ff 72 50 pushl 0x50(%edx) 10faad: e8 76 04 00 00 call 10ff28 the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10fab2: 83 c4 10 add $0x10,%esp 10fab5: 85 c0 test %eax,%eax 10fab7: 75 03 jne 10fabc <== NEVER TAKEN return rtems_deviceio_errno(status); return 0; } 10fab9: c9 leave 10faba: c3 ret 10fabb: 90 nop the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 10fabc: e8 73 fe ff ff call 10f934 <== NOT EXECUTED return 0; } 10fac1: c9 leave <== NOT EXECUTED 10fac2: c3 ret <== NOT EXECUTED =============================================================================== 0010f9f4 : ssize_t device_read( rtems_libio_t *iop, void *buffer, size_t count ) { 10f9f4: 55 push %ebp <== NOT EXECUTED 10f9f5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f9f7: 83 ec 2c sub $0x2c,%esp <== NOT EXECUTED 10f9fa: 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; 10f9fd: 8b 4a 2c mov 0x2c(%edx),%ecx <== NOT EXECUTED args.iop = iop; 10fa00: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED args.offset = iop->offset; 10fa03: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10fa06: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED args.buffer = buffer; 10fa09: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 10fa0c: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED args.count = count; 10fa0f: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 10fa12: 89 45 f4 mov %eax,-0xc(%ebp) <== NOT EXECUTED args.flags = iop->flags; 10fa15: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 10fa18: 89 45 f8 mov %eax,-0x8(%ebp) <== NOT EXECUTED args.bytes_moved = 0; 10fa1b: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) <== NOT EXECUTED status = rtems_io_read( 10fa22: 8d 45 e8 lea -0x18(%ebp),%eax <== NOT EXECUTED 10fa25: 50 push %eax <== NOT EXECUTED 10fa26: ff 71 54 pushl 0x54(%ecx) <== NOT EXECUTED 10fa29: ff 71 50 pushl 0x50(%ecx) <== NOT EXECUTED 10fa2c: e8 37 05 00 00 call 10ff68 <== NOT EXECUTED the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10fa31: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fa34: 85 c0 test %eax,%eax <== NOT EXECUTED 10fa36: 75 08 jne 10fa40 <== NOT EXECUTED return rtems_deviceio_errno(status); return (ssize_t) args.bytes_moved; 10fa38: 8b 45 fc mov -0x4(%ebp),%eax <== NOT EXECUTED } 10fa3b: c9 leave <== NOT EXECUTED 10fa3c: c3 ret <== NOT EXECUTED 10fa3d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 10fa40: e8 ef fe ff ff call 10f934 <== NOT EXECUTED return (ssize_t) args.bytes_moved; } 10fa45: c9 leave <== NOT EXECUTED 10fa46: c3 ret <== NOT EXECUTED =============================================================================== 0010f9a0 : ssize_t device_write( rtems_libio_t *iop, const void *buffer, size_t count ) { 10f9a0: 55 push %ebp 10f9a1: 89 e5 mov %esp,%ebp 10f9a3: 83 ec 2c sub $0x2c,%esp 10f9a6: 8b 55 08 mov 0x8(%ebp),%edx rtems_libio_rw_args_t args; rtems_status_code status; IMFS_jnode_t *the_jnode; the_jnode = iop->file_info; 10f9a9: 8b 4a 2c mov 0x2c(%edx),%ecx args.iop = iop; 10f9ac: 89 55 e8 mov %edx,-0x18(%ebp) args.offset = iop->offset; 10f9af: 8b 42 08 mov 0x8(%edx),%eax 10f9b2: 89 45 ec mov %eax,-0x14(%ebp) args.buffer = (void *) buffer; 10f9b5: 8b 45 0c mov 0xc(%ebp),%eax 10f9b8: 89 45 f0 mov %eax,-0x10(%ebp) args.count = count; 10f9bb: 8b 45 10 mov 0x10(%ebp),%eax 10f9be: 89 45 f4 mov %eax,-0xc(%ebp) args.flags = iop->flags; 10f9c1: 8b 42 0c mov 0xc(%edx),%eax 10f9c4: 89 45 f8 mov %eax,-0x8(%ebp) args.bytes_moved = 0; 10f9c7: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp) status = rtems_io_write( 10f9ce: 8d 45 e8 lea -0x18(%ebp),%eax 10f9d1: 50 push %eax 10f9d2: ff 71 54 pushl 0x54(%ecx) 10f9d5: ff 71 50 pushl 0x50(%ecx) 10f9d8: e8 cb 05 00 00 call 10ffa8 the_jnode->info.device.major, the_jnode->info.device.minor, (void *) &args ); if ( status ) 10f9dd: 83 c4 10 add $0x10,%esp 10f9e0: 85 c0 test %eax,%eax 10f9e2: 75 08 jne 10f9ec <== NEVER TAKEN return rtems_deviceio_errno(status); return (ssize_t) args.bytes_moved; 10f9e4: 8b 45 fc mov -0x4(%ebp),%eax } 10f9e7: c9 leave 10f9e8: c3 ret 10f9e9: 8d 76 00 lea 0x0(%esi),%esi the_jnode->info.device.minor, (void *) &args ); if ( status ) return rtems_deviceio_errno(status); 10f9ec: e8 43 ff ff ff call 10f934 <== NOT EXECUTED return (ssize_t) args.bytes_moved; } 10f9f1: c9 leave <== NOT EXECUTED 10f9f2: c3 ret <== NOT EXECUTED =============================================================================== 00108c54 : /* * Drain output queue */ static void drainOutput (struct rtems_termios_tty *tty) { 108c54: 55 push %ebp 108c55: 89 e5 mov %esp,%ebp 108c57: 53 push %ebx 108c58: 83 ec 04 sub $0x4,%esp 108c5b: 89 c3 mov %eax,%ebx rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) { 108c5d: 8b 80 b4 00 00 00 mov 0xb4(%eax),%eax 108c63: 85 c0 test %eax,%eax 108c65: 74 4d je 108cb4 <== NEVER TAKEN rtems_interrupt_disable (level); 108c67: 9c pushf 108c68: fa cli 108c69: 59 pop %ecx while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) { 108c6a: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx 108c70: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 108c76: 39 c2 cmp %eax,%edx 108c78: 74 38 je 108cb2 108c7a: 66 90 xchg %ax,%ax tty->rawOutBufState = rob_wait; 108c7c: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 108c83: 00 00 00 rtems_interrupt_enable (level); 108c86: 51 push %ecx 108c87: 9d popf sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, 108c88: 50 push %eax 108c89: 6a 00 push $0x0 108c8b: 6a 00 push $0x0 108c8d: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 108c93: e8 58 17 00 00 call 10a3f0 RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 108c98: 83 c4 10 add $0x10,%esp 108c9b: 85 c0 test %eax,%eax 108c9d: 75 1d jne 108cbc <== NEVER TAKEN rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); 108c9f: 9c pushf 108ca0: fa cli 108ca1: 59 pop %ecx 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) { 108ca2: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx 108ca8: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 108cae: 39 c2 cmp %eax,%edx 108cb0: 75 ca jne 108c7c <== NEVER TAKEN RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } rtems_interrupt_enable (level); 108cb2: 51 push %ecx 108cb3: 9d popf } } 108cb4: 8b 5d fc mov -0x4(%ebp),%ebx 108cb7: c9 leave 108cb8: c3 ret 108cb9: 8d 76 00 lea 0x0(%esi),%esi 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); 108cbc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108cbf: 50 push %eax <== NOT EXECUTED 108cc0: e8 bf 1d 00 00 call 10aa84 <== NOT EXECUTED =============================================================================== 001087f0 : /* * Echo a typed character */ static void echo (unsigned char c, struct rtems_termios_tty *tty) { 1087f0: 55 push %ebp <== NOT EXECUTED 1087f1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1087f3: 53 push %ebx <== NOT EXECUTED 1087f4: 83 ec 14 sub $0x14,%esp <== NOT EXECUTED 1087f7: 89 d3 mov %edx,%ebx <== NOT EXECUTED 1087f9: 88 c1 mov %al,%cl <== NOT EXECUTED if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) { 1087fb: f6 42 3d 02 testb $0x2,0x3d(%edx) <== NOT EXECUTED 1087ff: 74 0e je 10880f <== NOT EXECUTED 108801: 0f b6 d0 movzbl %al,%edx <== NOT EXECUTED 108804: a1 14 c5 11 00 mov 0x11c514,%eax <== NOT EXECUTED 108809: f6 04 10 20 testb $0x20,(%eax,%edx,1) <== NOT EXECUTED 10880d: 75 11 jne 108820 <== NOT EXECUTED echobuf[1] = c ^ 0x40; rtems_termios_puts (echobuf, 2, tty); tty->column += 2; } else { oproc (c, tty); 10880f: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 108812: 89 da mov %ebx,%edx <== NOT EXECUTED 108814: e8 a7 fe ff ff call 1086c0 <== NOT EXECUTED } } 108819: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10881c: c9 leave <== NOT EXECUTED 10881d: c3 ret <== NOT EXECUTED 10881e: 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')) { 108820: 80 f9 09 cmp $0x9,%cl <== NOT EXECUTED 108823: 74 ea je 10880f <== NOT EXECUTED 108825: 80 f9 0a cmp $0xa,%cl <== NOT EXECUTED 108828: 74 e5 je 10880f <== NOT EXECUTED char echobuf[2]; echobuf[0] = '^'; 10882a: c6 45 fa 5e movb $0x5e,-0x6(%ebp) <== NOT EXECUTED echobuf[1] = c ^ 0x40; 10882e: 83 f1 40 xor $0x40,%ecx <== NOT EXECUTED 108831: 88 4d fb mov %cl,-0x5(%ebp) <== NOT EXECUTED rtems_termios_puts (echobuf, 2, tty); 108834: 50 push %eax <== NOT EXECUTED 108835: 53 push %ebx <== NOT EXECUTED 108836: 6a 02 push $0x2 <== NOT EXECUTED 108838: 8d 45 fa lea -0x6(%ebp),%eax <== NOT EXECUTED 10883b: 50 push %eax <== NOT EXECUTED 10883c: e8 4f fd ff ff call 108590 <== NOT EXECUTED tty->column += 2; 108841: 83 43 28 02 addl $0x2,0x28(%ebx) <== NOT EXECUTED 108845: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { oproc (c, tty); } } 108848: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10884b: c9 leave <== NOT EXECUTED 10884c: c3 ret <== NOT EXECUTED =============================================================================== 00108850 : * 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) { 108850: 55 push %ebp <== NOT EXECUTED 108851: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108853: 57 push %edi <== NOT EXECUTED 108854: 56 push %esi <== NOT EXECUTED 108855: 53 push %ebx <== NOT EXECUTED 108856: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 108859: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10885b: 89 55 ec mov %edx,-0x14(%ebp) <== NOT EXECUTED if (tty->ccount == 0) 10885e: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED 108861: 85 c0 test %eax,%eax <== NOT EXECUTED 108863: 74 57 je 1088bc <== NOT EXECUTED return; if (lineFlag) { 108865: 85 d2 test %edx,%edx <== NOT EXECUTED 108867: 0f 85 bb 00 00 00 jne 108928 <== NOT EXECUTED 10886d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 108870: 8b 4b 3c mov 0x3c(%ebx),%ecx <== NOT EXECUTED echo ('\n', tty); return; } } while (tty->ccount) { unsigned char c = tty->cbuf[--tty->ccount]; 108873: 8b 53 1c mov 0x1c(%ebx),%edx <== NOT EXECUTED 108876: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 108879: 8d 78 ff lea -0x1(%eax),%edi <== NOT EXECUTED 10887c: 89 7b 20 mov %edi,0x20(%ebx) <== NOT EXECUTED 10887f: 8a 04 3a mov (%edx,%edi,1),%al <== NOT EXECUTED if (tty->termios.c_lflag & ECHO) { 108882: f6 c1 08 test $0x8,%cl <== NOT EXECUTED 108885: 74 25 je 1088ac <== NOT EXECUTED if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) { 108887: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10888a: 85 d2 test %edx,%edx <== NOT EXECUTED 10888c: 74 36 je 1088c4 <== NOT EXECUTED echo (tty->termios.c_cc[VERASE], tty); } else if (c == '\t') { 10888e: 3c 09 cmp $0x9,%al <== NOT EXECUTED 108890: 0f 84 d2 00 00 00 je 108968 <== NOT EXECUTED rtems_termios_puts ("\b", 1, tty); tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { 108896: 0f b6 f0 movzbl %al,%esi <== NOT EXECUTED 108899: a1 14 c5 11 00 mov 0x11c514,%eax <== NOT EXECUTED 10889e: f6 04 30 20 testb $0x20,(%eax,%esi,1) <== NOT EXECUTED 1088a2: 74 65 je 108909 <== NOT EXECUTED 1088a4: 80 e5 02 and $0x2,%ch <== NOT EXECUTED 1088a7: 75 33 jne 1088dc <== NOT EXECUTED 1088a9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED if (tty->column) tty->column--; } } } if (!lineFlag) 1088ac: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 1088af: 85 c0 test %eax,%eax <== NOT EXECUTED 1088b1: 74 09 je 1088bc <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) echo ('\n', tty); return; } } while (tty->ccount) { 1088b3: 8b 43 20 mov 0x20(%ebx),%eax <== NOT EXECUTED 1088b6: 85 c0 test %eax,%eax <== NOT EXECUTED 1088b8: 75 b6 jne 108870 <== NOT EXECUTED 1088ba: 66 90 xchg %ax,%ax <== NOT EXECUTED } } if (!lineFlag) break; } } 1088bc: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1088bf: 5b pop %ebx <== NOT EXECUTED 1088c0: 5e pop %esi <== NOT EXECUTED 1088c1: 5f pop %edi <== NOT EXECUTED 1088c2: c9 leave <== NOT EXECUTED 1088c3: 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)) { 1088c4: f6 c1 10 test $0x10,%cl <== NOT EXECUTED 1088c7: 75 c5 jne 10888e <== NOT EXECUTED echo (tty->termios.c_cc[VERASE], tty); 1088c9: 0f b6 43 43 movzbl 0x43(%ebx),%eax <== NOT EXECUTED 1088cd: 89 da mov %ebx,%edx <== NOT EXECUTED } } if (!lineFlag) break; } } 1088cf: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1088d2: 5b pop %ebx <== NOT EXECUTED 1088d3: 5e pop %esi <== NOT EXECUTED 1088d4: 5f pop %edi <== NOT EXECUTED 1088d5: 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); 1088d6: e9 15 ff ff ff jmp 1087f0 <== NOT EXECUTED 1088db: 90 nop <== NOT EXECUTED tty->column--; } } else { if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) { rtems_termios_puts ("\b \b", 3, tty); 1088dc: 52 push %edx <== NOT EXECUTED 1088dd: 53 push %ebx <== NOT EXECUTED 1088de: 6a 03 push $0x3 <== NOT EXECUTED 1088e0: 68 c3 85 11 00 push $0x1185c3 <== NOT EXECUTED 1088e5: e8 a6 fc ff ff call 108590 <== NOT EXECUTED if (tty->column) 1088ea: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 1088ed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1088f0: 85 c0 test %eax,%eax <== NOT EXECUTED 1088f2: 74 04 je 1088f8 <== NOT EXECUTED tty->column--; 1088f4: 48 dec %eax <== NOT EXECUTED 1088f5: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED } if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) { 1088f8: a1 14 c5 11 00 mov 0x11c514,%eax <== NOT EXECUTED 1088fd: f6 04 30 20 testb $0x20,(%eax,%esi,1) <== NOT EXECUTED 108901: 74 06 je 108909 <== NOT EXECUTED 108903: f6 43 3d 02 testb $0x2,0x3d(%ebx) <== NOT EXECUTED 108907: 74 a3 je 1088ac <== NOT EXECUTED rtems_termios_puts ("\b \b", 3, tty); 108909: 50 push %eax <== NOT EXECUTED 10890a: 53 push %ebx <== NOT EXECUTED 10890b: 6a 03 push $0x3 <== NOT EXECUTED 10890d: 68 c3 85 11 00 push $0x1185c3 <== NOT EXECUTED 108912: e8 79 fc ff ff call 108590 <== NOT EXECUTED if (tty->column) 108917: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 10891a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10891d: 85 c0 test %eax,%eax <== NOT EXECUTED 10891f: 74 8b je 1088ac <== NOT EXECUTED tty->column--; 108921: 48 dec %eax <== NOT EXECUTED 108922: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 108925: eb 85 jmp 1088ac <== NOT EXECUTED 108927: 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)) { 108928: 8b 4b 3c mov 0x3c(%ebx),%ecx <== NOT EXECUTED 10892b: f6 c1 08 test $0x8,%cl <== NOT EXECUTED 10892e: 0f 84 b4 00 00 00 je 1089e8 <== NOT EXECUTED tty->ccount = 0; return; } if (!(tty->termios.c_lflag & ECHOE)) { 108934: f6 c1 10 test $0x10,%cl <== NOT EXECUTED 108937: 0f 85 36 ff ff ff jne 108873 <== NOT EXECUTED tty->ccount = 0; 10893d: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED echo (tty->termios.c_cc[VKILL], tty); 108944: 0f b6 43 44 movzbl 0x44(%ebx),%eax <== NOT EXECUTED 108948: 89 da mov %ebx,%edx <== NOT EXECUTED 10894a: e8 a1 fe ff ff call 1087f0 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOK) 10894f: f6 43 3c 20 testb $0x20,0x3c(%ebx) <== NOT EXECUTED 108953: 0f 84 63 ff ff ff je 1088bc <== NOT EXECUTED echo ('\n', tty); 108959: 89 da mov %ebx,%edx <== NOT EXECUTED 10895b: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 108960: e9 6a ff ff ff jmp 1088cf <== NOT EXECUTED 108965: 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; 108968: 8b 73 2c mov 0x2c(%ebx),%esi <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 10896b: 85 ff test %edi,%edi <== NOT EXECUTED 10896d: 74 3f je 1089ae <== NOT EXECUTED c = tty->cbuf[i++]; if (c == '\t') { col = (col | 7) + 1; } else if (iscntrl (c)) { 10896f: a1 14 c5 11 00 mov 0x11c514,%eax <== NOT EXECUTED 108974: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 108977: 31 d2 xor %edx,%edx <== NOT EXECUTED if (tty->termios.c_lflag & ECHOCTL) 108979: 81 e1 00 02 00 00 and $0x200,%ecx <== NOT EXECUTED 10897f: 89 4d e4 mov %ecx,-0x1c(%ebp) <== NOT EXECUTED 108982: eb 0e jmp 108992 <== NOT EXECUTED 108984: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 108987: 85 c0 test %eax,%eax <== NOT EXECUTED 108989: 74 03 je 10898e <== NOT EXECUTED col += 2; 10898b: 83 c6 02 add $0x2,%esi <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 10898e: 39 d7 cmp %edx,%edi <== NOT EXECUTED 108990: 74 1c je 1089ae <== NOT EXECUTED c = tty->cbuf[i++]; 108992: 8b 4d e8 mov -0x18(%ebp),%ecx <== NOT EXECUTED 108995: 8a 04 11 mov (%ecx,%edx,1),%al <== NOT EXECUTED 108998: 42 inc %edx <== NOT EXECUTED if (c == '\t') { 108999: 3c 09 cmp $0x9,%al <== NOT EXECUTED 10899b: 74 3f je 1089dc <== NOT EXECUTED col = (col | 7) + 1; } else if (iscntrl (c)) { 10899d: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 1089a0: 8b 4d f0 mov -0x10(%ebp),%ecx <== NOT EXECUTED 1089a3: f6 04 01 20 testb $0x20,(%ecx,%eax,1) <== NOT EXECUTED 1089a7: 75 db jne 108984 <== NOT EXECUTED if (tty->termios.c_lflag & ECHOCTL) col += 2; } else { col++; 1089a9: 46 inc %esi <== NOT EXECUTED int i = 0; /* * Find the character before the tab */ while (i != tty->ccount) { 1089aa: 39 d7 cmp %edx,%edi <== NOT EXECUTED 1089ac: 75 e4 jne 108992 <== NOT EXECUTED } /* * Back up over the tab */ while (tty->column > col) { 1089ae: 39 73 28 cmp %esi,0x28(%ebx) <== NOT EXECUTED 1089b1: 0f 8e f5 fe ff ff jle 1088ac <== NOT EXECUTED 1089b7: 90 nop <== NOT EXECUTED rtems_termios_puts ("\b", 1, tty); 1089b8: 51 push %ecx <== NOT EXECUTED 1089b9: 53 push %ebx <== NOT EXECUTED 1089ba: 6a 01 push $0x1 <== NOT EXECUTED 1089bc: 68 c5 85 11 00 push $0x1185c5 <== NOT EXECUTED 1089c1: e8 ca fb ff ff call 108590 <== NOT EXECUTED tty->column--; 1089c6: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 1089c9: 48 dec %eax <== NOT EXECUTED 1089ca: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED } /* * Back up over the tab */ while (tty->column > col) { 1089cd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1089d0: 39 f0 cmp %esi,%eax <== NOT EXECUTED 1089d2: 7f e4 jg 1089b8 <== NOT EXECUTED 1089d4: e9 d3 fe ff ff jmp 1088ac <== NOT EXECUTED 1089d9: 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; 1089dc: 89 f0 mov %esi,%eax <== NOT EXECUTED 1089de: 83 c8 07 or $0x7,%eax <== NOT EXECUTED 1089e1: 8d 70 01 lea 0x1(%eax),%esi <== NOT EXECUTED 1089e4: eb a8 jmp 10898e <== NOT EXECUTED 1089e6: 66 90 xchg %ax,%ax <== NOT EXECUTED { if (tty->ccount == 0) return; if (lineFlag) { if (!(tty->termios.c_lflag & ECHO)) { tty->ccount = 0; 1089e8: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) <== NOT EXECUTED } } if (!lineFlag) break; } } 1089ef: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1089f2: 5b pop %ebx <== NOT EXECUTED 1089f3: 5e pop %esi <== NOT EXECUTED 1089f4: 5f pop %edi <== NOT EXECUTED 1089f5: c9 leave <== NOT EXECUTED 1089f6: c3 ret <== NOT EXECUTED =============================================================================== 001070c0 : void free( void *ptr ) { MSBUMP(free_calls, 1); 1070c0: 55 push %ebp 1070c1: 89 e5 mov %esp,%ebp 1070c3: 53 push %ebx 1070c4: 83 ec 04 sub $0x4,%esp 1070c7: 8b 5d 08 mov 0x8(%ebp),%ebx 1070ca: ff 05 6c e5 11 00 incl 0x11e56c if ( !ptr ) 1070d0: 85 db test %ebx,%ebx 1070d2: 74 4b je 10711f /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 1070d4: 83 3d 24 e8 11 00 03 cmpl $0x3,0x11e824 1070db: 74 47 je 107124 <== ALWAYS TAKEN #endif /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 1070dd: a1 e4 c9 11 00 mov 0x11c9e4,%eax 1070e2: 85 c0 test %eax,%eax 1070e4: 74 0a je 1070f0 <== ALWAYS TAKEN (*rtems_malloc_statistics_helpers->at_free)(ptr); 1070e6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1070e9: 53 push %ebx <== NOT EXECUTED 1070ea: ff 50 08 call *0x8(%eax) <== NOT EXECUTED 1070ed: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( !_Protected_heap_Free( &RTEMS_Malloc_Heap, ptr ) ) { 1070f0: 83 ec 08 sub $0x8,%esp 1070f3: 53 push %ebx 1070f4: 68 00 e5 11 00 push $0x11e500 1070f9: e8 92 4c 00 00 call 10bd90 <_Protected_heap_Free> 1070fe: 83 c4 10 add $0x10,%esp 107101: 84 c0 test %al,%al 107103: 75 1a jne 10711f <== ALWAYS TAKEN printk( "Program heap: free of bad pointer %p -- range %p - %p \n", 107105: ff 35 1c e5 11 00 pushl 0x11e51c <== NOT EXECUTED 10710b: ff 35 18 e5 11 00 pushl 0x11e518 <== NOT EXECUTED 107111: 53 push %ebx <== NOT EXECUTED 107112: 68 98 84 11 00 push $0x118498 <== NOT EXECUTED 107117: e8 1c 0d 00 00 call 107e38 <== NOT EXECUTED 10711c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED RTEMS_Malloc_Heap.begin, RTEMS_Malloc_Heap.end ); } } 10711f: 8b 5d fc mov -0x4(%ebp),%ebx 107122: c9 leave 107123: c3 ret /* * Do not attempt to free memory if in a critical section or ISR. */ if ( _System_state_Is_up(_System_state_Get()) && 107124: e8 af 00 00 00 call 1071d8 107129: 84 c0 test %al,%al 10712b: 75 b0 jne 1070dd <== ALWAYS TAKEN !malloc_is_system_state_OK() ) { malloc_deferred_free(ptr); 10712d: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED RTEMS_Malloc_Heap.begin, RTEMS_Malloc_Heap.end ); } } 107130: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 107133: 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); 107134: e9 df 00 00 00 jmp 107218 <== NOT EXECUTED =============================================================================== 00116538 : int fstat( int fd, struct stat *sbuf ) { 116538: 55 push %ebp 116539: 89 e5 mov %esp,%ebp 11653b: 57 push %edi 11653c: 56 push %esi 11653d: 53 push %ebx 11653e: 83 ec 0c sub $0xc,%esp 116541: 8b 55 08 mov 0x8(%ebp),%edx 116544: 8b 75 0c mov 0xc(%ebp),%esi /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) 116547: 85 f6 test %esi,%esi 116549: 74 7a je 1165c5 <== NEVER TAKEN /* * Now process the stat() request. */ iop = rtems_libio_iop( fd ); 11654b: 3b 15 40 a0 11 00 cmp 0x11a040,%edx 116551: 73 4d jae 1165a0 <== NEVER TAKEN 116553: 8d 04 52 lea (%edx,%edx,2),%eax 116556: 8d 04 82 lea (%edx,%eax,4),%eax 116559: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx 116560: 03 1d d0 e4 11 00 add 0x11e4d0,%ebx rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop); 116566: f6 43 0d 01 testb $0x1,0xd(%ebx) 11656a: 74 34 je 1165a0 <== NEVER TAKEN if ( !iop->handlers ) 11656c: 8b 43 30 mov 0x30(%ebx),%eax 11656f: 85 c0 test %eax,%eax 116571: 74 2d je 1165a0 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EBADF ); if ( !iop->handlers->fstat_h ) 116573: 8b 40 18 mov 0x18(%eax),%eax 116576: 85 c0 test %eax,%eax 116578: 74 3e je 1165b8 <== NEVER TAKEN /* * Zero out the stat structure so the various support * versions of stat don't have to. */ memset( sbuf, 0, sizeof(struct stat) ); 11657a: b9 4c 00 00 00 mov $0x4c,%ecx 11657f: 31 c0 xor %eax,%eax 116581: 89 f7 mov %esi,%edi 116583: f3 aa rep stos %al,%es:(%edi) return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf ); 116585: 8b 53 30 mov 0x30(%ebx),%edx 116588: 89 75 0c mov %esi,0xc(%ebp) 11658b: 8d 43 10 lea 0x10(%ebx),%eax 11658e: 89 45 08 mov %eax,0x8(%ebp) 116591: 8b 4a 18 mov 0x18(%edx),%ecx } 116594: 83 c4 0c add $0xc,%esp 116597: 5b pop %ebx 116598: 5e pop %esi 116599: 5f pop %edi 11659a: c9 leave * 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 ); 11659b: ff e1 jmp *%ecx 11659d: 8d 76 00 lea 0x0(%esi),%esi 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 ); 1165a0: e8 7b 9c ff ff call 110220 <__errno> <== NOT EXECUTED 1165a5: 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 ); } 1165ab: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1165b0: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 1165b3: 5b pop %ebx <== NOT EXECUTED 1165b4: 5e pop %esi <== NOT EXECUTED 1165b5: 5f pop %edi <== NOT EXECUTED 1165b6: c9 leave <== NOT EXECUTED 1165b7: 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 ); 1165b8: e8 63 9c ff ff call 110220 <__errno> <== NOT EXECUTED 1165bd: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1165c3: eb e6 jmp 1165ab <== NOT EXECUTED /* * Check to see if we were passed a valid pointer. */ if ( !sbuf ) rtems_set_errno_and_return_minus_one( EFAULT ); 1165c5: e8 56 9c ff ff call 110220 <__errno> <== NOT EXECUTED 1165ca: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 1165d0: eb d9 jmp 1165ab <== NOT EXECUTED =============================================================================== 0010e590 : int ftruncate( int fd, off_t length ) { 10e590: 55 push %ebp <== NOT EXECUTED 10e591: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e593: 57 push %edi <== NOT EXECUTED 10e594: 56 push %esi <== NOT EXECUTED 10e595: 53 push %ebx <== NOT EXECUTED 10e596: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 10e599: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED rtems_libio_t *iop; rtems_filesystem_location_info_t loc; rtems_libio_check_fd( fd ); 10e59c: 3b 15 40 a0 11 00 cmp 0x11a040,%edx <== NOT EXECUTED 10e5a2: 73 64 jae 10e608 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 10e5a4: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 10e5a7: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 10e5aa: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 10e5b1: 03 1d d0 e4 11 00 add 0x11e4d0,%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 10e5b7: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 10e5bb: 74 4b je 10e608 <== NOT EXECUTED /* * Make sure we are not working on a directory */ loc = iop->pathinfo; 10e5bd: 8d 55 e4 lea -0x1c(%ebp),%edx <== NOT EXECUTED 10e5c0: 8d 73 10 lea 0x10(%ebx),%esi <== NOT EXECUTED 10e5c3: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 10e5c8: 89 d7 mov %edx,%edi <== NOT EXECUTED 10e5ca: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !loc.ops->node_type_h ) 10e5cc: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10e5cf: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 10e5d2: 85 c0 test %eax,%eax <== NOT EXECUTED 10e5d4: 74 5a je 10e630 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) 10e5d6: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e5d9: 52 push %edx <== NOT EXECUTED 10e5da: ff d0 call *%eax <== NOT EXECUTED 10e5dc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e5df: 48 dec %eax <== NOT EXECUTED 10e5e0: 74 60 je 10e642 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EISDIR ); rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE ); 10e5e2: f6 43 0c 04 testb $0x4,0xc(%ebx) <== NOT EXECUTED 10e5e6: 74 34 je 10e61c <== NOT EXECUTED if ( !iop->handlers->ftruncate_h ) 10e5e8: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 10e5eb: 8b 40 20 mov 0x20(%eax),%eax <== NOT EXECUTED 10e5ee: 85 c0 test %eax,%eax <== NOT EXECUTED 10e5f0: 74 3e je 10e630 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); return (*iop->handlers->ftruncate_h)( iop, length ); 10e5f2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e5f5: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10e5f8: 53 push %ebx <== NOT EXECUTED 10e5f9: ff d0 call *%eax <== NOT EXECUTED 10e5fb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 10e5fe: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10e601: 5b pop %ebx <== NOT EXECUTED 10e602: 5e pop %esi <== NOT EXECUTED 10e603: 5f pop %edi <== NOT EXECUTED 10e604: c9 leave <== NOT EXECUTED 10e605: c3 ret <== NOT EXECUTED 10e606: 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); 10e608: e8 13 1c 00 00 call 110220 <__errno> <== NOT EXECUTED 10e60d: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 10e613: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e618: eb e4 jmp 10e5fe <== NOT EXECUTED 10e61a: 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 ); 10e61c: e8 ff 1b 00 00 call 110220 <__errno> <== NOT EXECUTED 10e621: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10e627: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e62c: eb d0 jmp 10e5fe <== NOT EXECUTED 10e62e: 66 90 xchg %ax,%ax <== NOT EXECUTED if ( !iop->handlers->ftruncate_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 10e630: e8 eb 1b 00 00 call 110220 <__errno> <== NOT EXECUTED 10e635: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10e63b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e640: eb bc jmp 10e5fe <== 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 ); 10e642: e8 d9 1b 00 00 call 110220 <__errno> <== NOT EXECUTED 10e647: c7 00 15 00 00 00 movl $0x15,(%eax) <== NOT EXECUTED 10e64d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e652: eb aa jmp 10e5fe <== NOT EXECUTED =============================================================================== 0011920c : * * 4.1.1 Get Process and Parent Process IDs, P1003.1b-1993, p. 83 */ pid_t getpid( void ) { 11920c: 55 push %ebp <== NOT EXECUTED 11920d: 89 e5 mov %esp,%ebp <== NOT EXECUTED return _Objects_Local_node; } 11920f: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 119214: c9 leave <== NOT EXECUTED 119215: c3 ret <== NOT EXECUTED =============================================================================== 0010e654 : int gettimeofday( struct timeval *tp, void * __tz ) { 10e654: 55 push %ebp 10e655: 89 e5 mov %esp,%ebp 10e657: 56 push %esi 10e658: 53 push %ebx 10e659: 83 ec 10 sub $0x10,%esp 10e65c: 8b 75 08 mov 0x8(%ebp),%esi /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) { 10e65f: 85 f6 test %esi,%esi 10e661: 74 30 je 10e693 <== NEVER TAKEN ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 10e663: 9c pushf 10e664: fa cli 10e665: 5b pop %ebx * This routine grows @a the_heap memory area using the size bytes which 10e666: 83 ec 0c sub $0xc,%esp 10e669: 8d 45 f0 lea -0x10(%ebp),%eax 10e66c: 50 push %eax 10e66d: e8 ca cb ff ff call 10b23c <_TOD_Get> * begin at @a starting_address. 10e672: 53 push %ebx 10e673: 9d popf * * @param[in] the_heap is the heap to operate upon 10e674: 8b 45 f0 mov -0x10(%ebp),%eax 10e677: 89 06 mov %eax,(%esi) * @param[in] starting_address is the starting address of the memory 10e679: b8 d3 4d 62 10 mov $0x10624dd3,%eax 10e67e: f7 65 f4 mull -0xc(%ebp) 10e681: c1 ea 06 shr $0x6,%edx 10e684: 89 56 04 mov %edx,0x4(%esi) 10e687: 31 c0 xor %eax,%eax 10e689: 83 c4 10 add $0x10,%esp * with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X * do it. This puts us in good company. */ return 0; } 10e68c: 8d 65 f8 lea -0x8(%ebp),%esp 10e68f: 5b pop %ebx 10e690: 5e pop %esi 10e691: c9 leave 10e692: c3 ret void * __tz ) { /* struct timezone* tzp = (struct timezone*) __tz; */ if ( !tp ) { errno = EFAULT; 10e693: e8 88 1b 00 00 call 110220 <__errno> <== NOT EXECUTED 10e698: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 10e69e: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10e6a3: eb e7 jmp 10e68c <== NOT EXECUTED =============================================================================== 001089f8 : /* * Process a single input character */ static int iproc (unsigned char c, struct rtems_termios_tty *tty) { 1089f8: 55 push %ebp <== NOT EXECUTED 1089f9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1089fb: 56 push %esi <== NOT EXECUTED 1089fc: 53 push %ebx <== NOT EXECUTED 1089fd: 89 d6 mov %edx,%esi <== NOT EXECUTED 1089ff: 88 c3 mov %al,%bl <== NOT EXECUTED if (tty->termios.c_iflag & ISTRIP) 108a01: 8b 4a 30 mov 0x30(%edx),%ecx <== NOT EXECUTED 108a04: f6 c1 20 test $0x20,%cl <== NOT EXECUTED 108a07: 74 03 je 108a0c <== NOT EXECUTED c &= 0x7f; 108a09: 83 e3 7f and $0x7f,%ebx <== NOT EXECUTED if (tty->termios.c_iflag & IUCLC) 108a0c: f6 c5 02 test $0x2,%ch <== NOT EXECUTED 108a0f: 74 10 je 108a21 <== NOT EXECUTED c = tolower (c); 108a11: 0f b6 d3 movzbl %bl,%edx <== NOT EXECUTED 108a14: a1 14 c5 11 00 mov 0x11c514,%eax <== NOT EXECUTED 108a19: f6 04 10 01 testb $0x1,(%eax,%edx,1) <== NOT EXECUTED 108a1d: 75 3d jne 108a5c <== NOT EXECUTED 108a1f: 88 d3 mov %dl,%bl <== NOT EXECUTED if (c == '\r') { 108a21: 80 fb 0d cmp $0xd,%bl <== NOT EXECUTED 108a24: 0f 84 8a 00 00 00 je 108ab4 <== 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)) { 108a2a: 80 fb 0a cmp $0xa,%bl <== NOT EXECUTED 108a2d: 74 35 je 108a64 <== NOT EXECUTED c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 108a2f: 84 db test %bl,%bl <== NOT EXECUTED 108a31: 75 36 jne 108a69 <== NOT EXECUTED } /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { 108a33: 8b 56 20 mov 0x20(%esi),%edx <== NOT EXECUTED 108a36: a1 84 c4 11 00 mov 0x11c484,%eax <== NOT EXECUTED 108a3b: 48 dec %eax <== NOT EXECUTED 108a3c: 39 c2 cmp %eax,%edx <== NOT EXECUTED 108a3e: 7d 78 jge 108ab8 <== NOT EXECUTED if (tty->termios.c_lflag & ECHO) 108a40: f6 46 3c 08 testb $0x8,0x3c(%esi) <== NOT EXECUTED 108a44: 0f 85 86 00 00 00 jne 108ad0 <== NOT EXECUTED echo (c, tty); tty->cbuf[tty->ccount++] = c; 108a4a: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 108a4d: 88 1c 10 mov %bl,(%eax,%edx,1) <== NOT EXECUTED 108a50: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 108a53: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED 108a56: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 108a58: 5b pop %ebx <== NOT EXECUTED 108a59: 5e pop %esi <== NOT EXECUTED 108a5a: c9 leave <== NOT EXECUTED 108a5b: 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); 108a5c: 83 c2 20 add $0x20,%edx <== NOT EXECUTED 108a5f: eb be jmp 108a1f <== NOT EXECUTED 108a61: 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)) { 108a64: 83 e1 40 and $0x40,%ecx <== NOT EXECUTED 108a67: 75 63 jne 108acc <== NOT EXECUTED c = '\r'; } if ((c != '\0') && (tty->termios.c_lflag & ICANON)) { 108a69: 8b 46 3c mov 0x3c(%esi),%eax <== NOT EXECUTED 108a6c: a8 02 test $0x2,%al <== NOT EXECUTED 108a6e: 74 c3 je 108a33 <== NOT EXECUTED if (c == tty->termios.c_cc[VERASE]) { 108a70: 38 5e 43 cmp %bl,0x43(%esi) <== NOT EXECUTED 108a73: 74 6f je 108ae4 <== NOT EXECUTED erase (tty, 0); return 0; } else if (c == tty->termios.c_cc[VKILL]) { 108a75: 38 5e 44 cmp %bl,0x44(%esi) <== NOT EXECUTED 108a78: 0f 84 9e 00 00 00 je 108b1c <== NOT EXECUTED erase (tty, 1); return 0; } else if (c == tty->termios.c_cc[VEOF]) { 108a7e: 38 5e 45 cmp %bl,0x45(%esi) <== NOT EXECUTED 108a81: 74 2a je 108aad <== NOT EXECUTED return 1; } else if (c == '\n') { 108a83: 80 fb 0a cmp $0xa,%bl <== NOT EXECUTED 108a86: 74 6c je 108af4 <== 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]) 108a88: 38 5e 4c cmp %bl,0x4c(%esi) <== NOT EXECUTED 108a8b: 74 05 je 108a92 <== NOT EXECUTED 108a8d: 38 5e 51 cmp %bl,0x51(%esi) <== NOT EXECUTED 108a90: 75 a1 jne 108a33 <== NOT EXECUTED || (c == tty->termios.c_cc[VEOL2])) { if (tty->termios.c_lflag & ECHO) 108a92: a8 08 test $0x8,%al <== NOT EXECUTED 108a94: 74 0a je 108aa0 <== NOT EXECUTED echo (c, tty); 108a96: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 108a99: 89 f2 mov %esi,%edx <== NOT EXECUTED 108a9b: e8 50 fd ff ff call 1087f0 <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 108aa0: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 108aa3: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED 108aa6: 88 1c 02 mov %bl,(%edx,%eax,1) <== NOT EXECUTED 108aa9: 40 inc %eax <== NOT EXECUTED 108aaa: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED 108aad: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 108ab2: eb a4 jmp 108a58 <== 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) 108ab4: 84 c9 test %cl,%cl <== NOT EXECUTED 108ab6: 79 08 jns 108ac0 <== 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; 108ab8: 31 c0 xor %eax,%eax <== NOT EXECUTED } return 0; } 108aba: 5b pop %ebx <== NOT EXECUTED 108abb: 5e pop %esi <== NOT EXECUTED 108abc: c9 leave <== NOT EXECUTED 108abd: c3 ret <== NOT EXECUTED 108abe: 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) 108ac0: 80 e5 01 and $0x1,%ch <== NOT EXECUTED 108ac3: 74 a4 je 108a69 <== NOT EXECUTED 108ac5: b3 0a mov $0xa,%bl <== NOT EXECUTED 108ac7: eb a0 jmp 108a69 <== NOT EXECUTED 108ac9: 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; 108acc: b3 0d mov $0xd,%bl <== NOT EXECUTED 108ace: eb 99 jmp 108a69 <== NOT EXECUTED /* * FIXME: Should do IMAXBEL handling somehow */ if (tty->ccount < (CBUFSIZE-1)) { if (tty->termios.c_lflag & ECHO) echo (c, tty); 108ad0: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 108ad3: 89 f2 mov %esi,%edx <== NOT EXECUTED 108ad5: e8 16 fd ff ff call 1087f0 <== NOT EXECUTED 108ada: 8b 56 20 mov 0x20(%esi),%edx <== NOT EXECUTED 108add: e9 68 ff ff ff jmp 108a4a <== NOT EXECUTED 108ae2: 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); 108ae4: 31 d2 xor %edx,%edx <== NOT EXECUTED 108ae6: 89 f0 mov %esi,%eax <== NOT EXECUTED 108ae8: e8 63 fd ff ff call 108850 <== NOT EXECUTED 108aed: 31 c0 xor %eax,%eax <== NOT EXECUTED 108aef: e9 64 ff ff ff jmp 108a58 <== NOT EXECUTED } else if (c == tty->termios.c_cc[VEOF]) { return 1; } else if (c == '\n') { if (tty->termios.c_lflag & (ECHO | ECHONL)) 108af4: a8 48 test $0x48,%al <== NOT EXECUTED 108af6: 74 0c je 108b04 <== NOT EXECUTED echo (c, tty); 108af8: 89 f2 mov %esi,%edx <== NOT EXECUTED 108afa: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED 108aff: e8 ec fc ff ff call 1087f0 <== NOT EXECUTED tty->cbuf[tty->ccount++] = c; 108b04: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 108b07: 8b 56 1c mov 0x1c(%esi),%edx <== NOT EXECUTED 108b0a: c6 04 02 0a movb $0xa,(%edx,%eax,1) <== NOT EXECUTED 108b0e: 40 inc %eax <== NOT EXECUTED 108b0f: 89 46 20 mov %eax,0x20(%esi) <== NOT EXECUTED 108b12: b8 01 00 00 00 mov $0x1,%eax <== NOT EXECUTED 108b17: e9 3c ff ff ff jmp 108a58 <== 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); 108b1c: ba 01 00 00 00 mov $0x1,%edx <== NOT EXECUTED 108b21: 89 f0 mov %esi,%eax <== NOT EXECUTED 108b23: e8 28 fd ff ff call 108850 <== NOT EXECUTED 108b28: 31 c0 xor %eax,%eax <== NOT EXECUTED 108b2a: e9 29 ff ff ff jmp 108a58 <== NOT EXECUTED =============================================================================== 001165ec : #include int isatty( int fd ) { 1165ec: 55 push %ebp 1165ed: 89 e5 mov %esp,%ebp 1165ef: 83 ec 60 sub $0x60,%esp struct stat buf; if (fstat (fd, &buf) < 0) 1165f2: 8d 45 b4 lea -0x4c(%ebp),%eax 1165f5: 50 push %eax 1165f6: ff 75 08 pushl 0x8(%ebp) 1165f9: e8 3a ff ff ff call 116538 1165fe: 83 c4 10 add $0x10,%esp 116601: 85 c0 test %eax,%eax 116603: 78 17 js 11661c <== NEVER TAKEN 116605: 8b 45 c0 mov -0x40(%ebp),%eax 116608: 25 00 f0 00 00 and $0xf000,%eax 11660d: 3d 00 20 00 00 cmp $0x2000,%eax 116612: 0f 94 c0 sete %al 116615: 0f b6 c0 movzbl %al,%eax if (S_ISCHR (buf.st_mode)) return 1; return 0; } 116618: c9 leave 116619: c3 ret 11661a: 66 90 xchg %ax,%ax int fd ) { struct stat buf; if (fstat (fd, &buf) < 0) 11661c: 31 c0 xor %eax,%eax if (S_ISCHR (buf.st_mode)) return 1; return 0; } 11661e: c9 leave <== NOT EXECUTED 11661f: c3 ret <== NOT EXECUTED =============================================================================== 00119340 : * These are directly supported (and completely correct) in the posix api. */ #if !defined(RTEMS_POSIX_API) int kill( pid_t pid, int sig ) { 119340: 55 push %ebp <== NOT EXECUTED 119341: 89 e5 mov %esp,%ebp <== NOT EXECUTED return 0; } 119343: 31 c0 xor %eax,%eax <== NOT EXECUTED 119345: c9 leave <== NOT EXECUTED 119346: c3 ret <== NOT EXECUTED =============================================================================== 001075c4 : */ bool libc_create_hook( rtems_tcb *current_task, rtems_tcb *creating_task ) { 1075c4: 55 push %ebp 1075c5: 89 e5 mov %esp,%ebp 1075c7: 57 push %edi 1075c8: 56 push %esi 1075c9: 53 push %ebx 1075ca: 83 ec 18 sub $0x18,%esp 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)); 1075cd: 68 00 04 00 00 push $0x400 1075d2: e8 49 5e 00 00 call 10d420 <_Workspace_Allocate> 1075d7: 89 c6 mov %eax,%esi #endif if (ptr) { 1075d9: 83 c4 10 add $0x10,%esp 1075dc: 85 c0 test %eax,%eax 1075de: 0f 84 30 02 00 00 je 107814 <== NEVER TAKEN _REENT_INIT_PTR((ptr)); /* GCC extension: structure constants */ 1075e4: c7 00 00 00 00 00 movl $0x0,(%eax) 1075ea: 8d 90 ec 02 00 00 lea 0x2ec(%eax),%edx 1075f0: 89 50 04 mov %edx,0x4(%eax) 1075f3: 8d 80 48 03 00 00 lea 0x348(%eax),%eax 1075f9: 89 46 08 mov %eax,0x8(%esi) 1075fc: 8d 86 a4 03 00 00 lea 0x3a4(%esi),%eax 107602: 89 46 0c mov %eax,0xc(%esi) 107605: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi) 10760c: 8d 7e 14 lea 0x14(%esi),%edi 10760f: 31 c0 xor %eax,%eax 107611: bb 19 00 00 00 mov $0x19,%ebx 107616: 89 d9 mov %ebx,%ecx 107618: f3 aa rep stos %al,%es:(%edi) 10761a: c7 46 30 00 00 00 00 movl $0x0,0x30(%esi) 107621: c7 46 34 d0 84 11 00 movl $0x1184d0,0x34(%esi) 107628: c7 46 38 00 00 00 00 movl $0x0,0x38(%esi) 10762f: c7 46 3c 00 00 00 00 movl $0x0,0x3c(%esi) 107636: c7 46 40 00 00 00 00 movl $0x0,0x40(%esi) 10763d: c7 46 44 00 00 00 00 movl $0x0,0x44(%esi) 107644: c7 46 48 00 00 00 00 movl $0x0,0x48(%esi) 10764b: c7 46 4c 00 00 00 00 movl $0x0,0x4c(%esi) 107652: c7 46 50 00 00 00 00 movl $0x0,0x50(%esi) 107659: c7 46 54 00 00 00 00 movl $0x0,0x54(%esi) 107660: c7 46 58 00 00 00 00 movl $0x0,0x58(%esi) 107667: c7 46 5c 00 00 00 00 movl $0x0,0x5c(%esi) 10766e: c6 46 60 00 movb $0x0,0x60(%esi) 107672: 8d 7e 7c lea 0x7c(%esi),%edi 107675: b3 24 mov $0x24,%bl 107677: 89 d9 mov %ebx,%ecx 107679: f3 aa rep stos %al,%es:(%edi) 10767b: c7 86 a0 00 00 00 00 movl $0x0,0xa0(%esi) 107682: 00 00 00 107685: c7 86 a4 00 00 00 01 movl $0x1,0xa4(%esi) 10768c: 00 00 00 10768f: c7 86 a8 00 00 00 00 movl $0x0,0xa8(%esi) 107696: 00 00 00 107699: 66 c7 86 ac 00 00 00 movw $0x330e,0xac(%esi) 1076a0: 0e 33 1076a2: 66 c7 86 ae 00 00 00 movw $0xabcd,0xae(%esi) 1076a9: cd ab 1076ab: 66 c7 86 b0 00 00 00 movw $0x1234,0xb0(%esi) 1076b2: 34 12 1076b4: 66 c7 86 b2 00 00 00 movw $0xe66d,0xb2(%esi) 1076bb: 6d e6 1076bd: 66 c7 86 b4 00 00 00 movw $0xdeec,0xb4(%esi) 1076c4: ec de 1076c6: 66 c7 86 b6 00 00 00 movw $0x5,0xb6(%esi) 1076cd: 05 00 1076cf: 66 c7 86 b8 00 00 00 movw $0xb,0xb8(%esi) 1076d6: 0b 00 1076d8: c7 86 bc 00 00 00 00 movl $0x0,0xbc(%esi) 1076df: 00 00 00 1076e2: c7 86 c0 00 00 00 00 movl $0x0,0xc0(%esi) 1076e9: 00 00 00 1076ec: c7 86 c4 00 00 00 00 movl $0x0,0xc4(%esi) 1076f3: 00 00 00 1076f6: c7 86 c8 00 00 00 00 movl $0x0,0xc8(%esi) 1076fd: 00 00 00 107700: c7 86 cc 00 00 00 00 movl $0x0,0xcc(%esi) 107707: 00 00 00 10770a: c7 86 d0 00 00 00 00 movl $0x0,0xd0(%esi) 107711: 00 00 00 107714: c7 86 f8 00 00 00 00 movl $0x0,0xf8(%esi) 10771b: 00 00 00 10771e: c7 86 fc 00 00 00 00 movl $0x0,0xfc(%esi) 107725: 00 00 00 107728: c7 86 00 01 00 00 00 movl $0x0,0x100(%esi) 10772f: 00 00 00 107732: c7 86 04 01 00 00 00 movl $0x0,0x104(%esi) 107739: 00 00 00 10773c: c7 86 08 01 00 00 00 movl $0x0,0x108(%esi) 107743: 00 00 00 107746: c7 86 0c 01 00 00 00 movl $0x0,0x10c(%esi) 10774d: 00 00 00 107750: c7 86 10 01 00 00 00 movl $0x0,0x110(%esi) 107757: 00 00 00 10775a: c7 86 14 01 00 00 00 movl $0x0,0x114(%esi) 107761: 00 00 00 107764: c7 86 18 01 00 00 00 movl $0x0,0x118(%esi) 10776b: 00 00 00 10776e: c7 86 1c 01 00 00 00 movl $0x0,0x11c(%esi) 107775: 00 00 00 107778: c6 86 d4 00 00 00 00 movb $0x0,0xd4(%esi) 10777f: c6 86 dc 00 00 00 00 movb $0x0,0xdc(%esi) 107786: c7 86 f4 00 00 00 00 movl $0x0,0xf4(%esi) 10778d: 00 00 00 107790: c7 86 48 01 00 00 00 movl $0x0,0x148(%esi) 107797: 00 00 00 10779a: c7 86 4c 01 00 00 00 movl $0x0,0x14c(%esi) 1077a1: 00 00 00 1077a4: c7 86 50 01 00 00 00 movl $0x0,0x150(%esi) 1077ab: 00 00 00 1077ae: c7 86 54 01 00 00 00 movl $0x0,0x154(%esi) 1077b5: 00 00 00 1077b8: c7 86 d4 02 00 00 00 movl $0x0,0x2d4(%esi) 1077bf: 00 00 00 1077c2: c7 86 d4 01 00 00 00 movl $0x0,0x1d4(%esi) 1077c9: 00 00 00 1077cc: c7 86 dc 02 00 00 00 movl $0x0,0x2dc(%esi) 1077d3: 00 00 00 1077d6: c7 86 e0 02 00 00 00 movl $0x0,0x2e0(%esi) 1077dd: 00 00 00 1077e0: c7 86 e4 02 00 00 00 movl $0x0,0x2e4(%esi) 1077e7: 00 00 00 1077ea: c7 86 e8 02 00 00 00 movl $0x0,0x2e8(%esi) 1077f1: 00 00 00 1077f4: 66 bb 14 01 mov $0x114,%bx 1077f8: 89 d7 mov %edx,%edi 1077fa: 89 d9 mov %ebx,%ecx 1077fc: f3 aa rep stos %al,%es:(%edi) creating_task->libc_reent = ptr; 1077fe: 8b 45 0c mov 0xc(%ebp),%eax 107801: 89 b0 f0 00 00 00 mov %esi,0xf0(%eax) 107807: b0 01 mov $0x1,%al return true; } else return false; } 107809: 8d 65 f4 lea -0xc(%ebp),%esp 10780c: 5b pop %ebx 10780d: 5e pop %esi 10780e: 5f pop %edi 10780f: c9 leave 107810: c3 ret 107811: 8d 76 00 lea 0x0(%esi),%esi * hooks run with thread dispatching disabled. */ ptr = (struct _reent *) _Workspace_Allocate(sizeof(struct _reent)); #endif if (ptr) { 107814: 31 c0 xor %eax,%eax creating_task->libc_reent = ptr; return true; } else return false; } 107816: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107819: 5b pop %ebx <== NOT EXECUTED 10781a: 5e pop %esi <== NOT EXECUTED 10781b: 5f pop %edi <== NOT EXECUTED 10781c: c9 leave <== NOT EXECUTED 10781d: c3 ret <== NOT EXECUTED =============================================================================== 001074f8 : rtems_extension libc_delete_hook( rtems_tcb *current_task, rtems_tcb *deleted_task ) { 1074f8: 55 push %ebp 1074f9: 89 e5 mov %esp,%ebp 1074fb: 57 push %edi 1074fc: 56 push %esi 1074fd: 53 push %ebx 1074fe: 83 ec 0c sub $0xc,%esp 107501: 8b 7d 08 mov 0x8(%ebp),%edi 107504: 8b 75 0c mov 0xc(%ebp),%esi /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) { 107507: 39 f7 cmp %esi,%edi 107509: 74 55 je 107560 ptr = _REENT; } else { ptr = deleted_task->libc_reent; 10750b: 8b 9e f0 00 00 00 mov 0xf0(%esi),%ebx } if (ptr && ptr != &libc_global_reent) { 107511: 85 db test %ebx,%ebx 107513: 74 21 je 107536 <== NEVER TAKEN 107515: 81 fb 80 c0 11 00 cmp $0x11c080,%ebx 10751b: 74 19 je 107536 _reclaim_reent(ptr); */ /* * Just in case there are some buffers lying around. */ _fwalk(ptr, newlib_free_buffers); 10751d: 83 ec 08 sub $0x8,%esp 107520: 68 68 75 10 00 push $0x107568 107525: 53 push %ebx 107526: e8 ad 93 00 00 call 1108d8 <_fwalk> #if REENT_MALLOCED free(ptr); #else _Workspace_Free(ptr); 10752b: 89 1c 24 mov %ebx,(%esp) 10752e: e8 d5 5e 00 00 call 10d408 <_Workspace_Free> 107533: 83 c4 10 add $0x10,%esp #endif } deleted_task->libc_reent = NULL; 107536: c7 86 f0 00 00 00 00 movl $0x0,0xf0(%esi) 10753d: 00 00 00 /* * Require the switch back to another task to install its own */ if ( current_task == deleted_task ) { 107540: 39 f7 cmp %esi,%edi 107542: 74 08 je 10754c _REENT = 0; } } 107544: 8d 65 f4 lea -0xc(%ebp),%esp 107547: 5b pop %ebx 107548: 5e pop %esi 107549: 5f pop %edi 10754a: c9 leave 10754b: c3 ret /* * Require the switch back to another task to install its own */ if ( current_task == deleted_task ) { _REENT = 0; 10754c: c7 05 20 c5 11 00 00 movl $0x0,0x11c520 107553: 00 00 00 } } 107556: 8d 65 f4 lea -0xc(%ebp),%esp 107559: 5b pop %ebx 10755a: 5e pop %esi 10755b: 5f pop %edi 10755c: c9 leave 10755d: c3 ret 10755e: 66 90 xchg %ax,%ax /* * The reentrancy structure was allocated by newlib using malloc() */ if (current_task == deleted_task) { ptr = _REENT; 107560: 8b 1d 20 c5 11 00 mov 0x11c520,%ebx 107566: eb a9 jmp 107511 =============================================================================== 00116708 : extern void _wrapup_reent(struct _reent *); extern void _reclaim_reent(struct _reent *); void libc_wrapup(void) { 116708: 55 push %ebp 116709: 89 e5 mov %esp,%ebp 11670b: 83 ec 08 sub $0x8,%esp /* * In case RTEMS is already down, don't do this. It could be * dangerous. */ if (!_System_state_Is_up(_System_state_Get())) 11670e: 83 3d 24 e8 11 00 03 cmpl $0x3,0x11e824 116715: 74 05 je 11671c <== ALWAYS TAKEN */ fclose (stdin); fclose (stdout); fclose (stderr); } 116717: c9 leave <== NOT EXECUTED 116718: c3 ret <== NOT EXECUTED 116719: 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) { 11671c: 81 3d 20 c5 11 00 80 cmpl $0x11c080,0x11c520 116723: c0 11 00 116726: 74 1a je 116742 _wrapup_reent(&libc_global_reent); 116728: 83 ec 0c sub $0xc,%esp 11672b: 68 80 c0 11 00 push $0x11c080 116730: e8 eb 05 00 00 call 116d20 <_wrapup_reent> /* 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; 116735: c7 05 20 c5 11 00 80 movl $0x11c080,0x11c520 11673c: c0 11 00 11673f: 83 c4 10 add $0x10,%esp * * Should this be changed to do *all* file streams? * _fwalk (_REENT, fclose); */ fclose (stdin); 116742: 83 ec 0c sub $0xc,%esp 116745: a1 20 c5 11 00 mov 0x11c520,%eax 11674a: ff 70 04 pushl 0x4(%eax) 11674d: e8 1a 9c ff ff call 11036c fclose (stdout); 116752: 5a pop %edx 116753: a1 20 c5 11 00 mov 0x11c520,%eax 116758: ff 70 08 pushl 0x8(%eax) 11675b: e8 0c 9c ff ff call 11036c fclose (stderr); 116760: 58 pop %eax 116761: a1 20 c5 11 00 mov 0x11c520,%eax 116766: ff 70 0c pushl 0xc(%eax) 116769: e8 fe 9b ff ff call 11036c 11676e: 83 c4 10 add $0x10,%esp } 116771: c9 leave 116772: c3 ret =============================================================================== 00116620 : off_t lseek( int fd, off_t offset, int whence ) { 116620: 55 push %ebp <== NOT EXECUTED 116621: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116623: 57 push %edi <== NOT EXECUTED 116624: 56 push %esi <== NOT EXECUTED 116625: 53 push %ebx <== NOT EXECUTED 116626: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116629: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 11662c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11662f: 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 ); 116632: 3b 15 40 a0 11 00 cmp 0x11a040,%edx <== NOT EXECUTED 116638: 73 7e jae 1166b8 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 11663a: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 11663d: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 116640: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 116647: 03 1d d0 e4 11 00 add 0x11e4d0,%ebx <== NOT EXECUTED rtems_libio_check_is_open(iop); 11664d: f6 43 0d 01 testb $0x1,0xd(%ebx) <== NOT EXECUTED 116651: 74 65 je 1166b8 <== NOT EXECUTED /* * Check as many errors as possible before touching iop->offset. */ if ( !iop->handlers->lseek_h ) 116653: 8b 53 30 mov 0x30(%ebx),%edx <== NOT EXECUTED 116656: 8b 7a 14 mov 0x14(%edx),%edi <== NOT EXECUTED 116659: 85 ff test %edi,%edi <== NOT EXECUTED 11665b: 74 6d je 1166ca <== NOT EXECUTED /* * Now process the lseek(). */ old_offset = iop->offset; 11665d: 8b 7b 08 mov 0x8(%ebx),%edi <== NOT EXECUTED switch ( whence ) { 116660: 83 f9 01 cmp $0x1,%ecx <== NOT EXECUTED 116663: 74 4b je 1166b0 <== NOT EXECUTED 116665: 83 f9 02 cmp $0x2,%ecx <== NOT EXECUTED 116668: 74 22 je 11668c <== NOT EXECUTED 11666a: 85 c9 test %ecx,%ecx <== NOT EXECUTED 11666c: 75 2a jne 116698 <== NOT EXECUTED case SEEK_SET: iop->offset = offset; 11666e: 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 ); 116671: 50 push %eax <== NOT EXECUTED 116672: 51 push %ecx <== NOT EXECUTED 116673: 56 push %esi <== NOT EXECUTED 116674: 53 push %ebx <== NOT EXECUTED 116675: ff 52 14 call *0x14(%edx) <== NOT EXECUTED if ( status == (off_t) -1 ) 116678: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11667b: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 11667e: 75 03 jne 116683 <== NOT EXECUTED iop->offset = old_offset; 116680: 89 7b 08 mov %edi,0x8(%ebx) <== NOT EXECUTED /* * So if the operation failed, we have to restore iop->offset. */ return status; } 116683: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 116686: 5b pop %ebx <== NOT EXECUTED 116687: 5e pop %esi <== NOT EXECUTED 116688: 5f pop %edi <== NOT EXECUTED 116689: c9 leave <== NOT EXECUTED 11668a: c3 ret <== NOT EXECUTED 11668b: 90 nop <== NOT EXECUTED case SEEK_CUR: iop->offset += offset; break; case SEEK_END: iop->offset = iop->size + offset; 11668c: 89 f0 mov %esi,%eax <== NOT EXECUTED 11668e: 03 43 04 add 0x4(%ebx),%eax <== NOT EXECUTED 116691: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED 116694: eb db jmp 116671 <== NOT EXECUTED 116696: 66 90 xchg %ax,%ax <== NOT EXECUTED break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 116698: e8 83 9b ff ff call 110220 <__errno> <== NOT EXECUTED 11669d: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1166a3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED /* * So if the operation failed, we have to restore iop->offset. */ return status; } 1166a8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1166ab: 5b pop %ebx <== NOT EXECUTED 1166ac: 5e pop %esi <== NOT EXECUTED 1166ad: 5f pop %edi <== NOT EXECUTED 1166ae: c9 leave <== NOT EXECUTED 1166af: c3 ret <== NOT EXECUTED case SEEK_SET: iop->offset = offset; break; case SEEK_CUR: iop->offset += offset; 1166b0: 8d 04 3e lea (%esi,%edi,1),%eax <== NOT EXECUTED 1166b3: 89 43 08 mov %eax,0x8(%ebx) <== NOT EXECUTED 1166b6: eb b9 jmp 116671 <== 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); 1166b8: e8 63 9b ff ff call 110220 <__errno> <== NOT EXECUTED 1166bd: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 1166c3: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1166c8: eb b9 jmp 116683 <== 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 ); 1166ca: e8 51 9b ff ff call 110220 <__errno> <== NOT EXECUTED 1166cf: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 1166d5: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 1166da: eb a7 jmp 116683 <== NOT EXECUTED =============================================================================== 001072d8 : size_t size ) { void *return_this; MSBUMP(malloc_calls, 1); 1072d8: 55 push %ebp 1072d9: 89 e5 mov %esp,%ebp 1072db: 57 push %edi 1072dc: 56 push %esi 1072dd: 53 push %ebx 1072de: 83 ec 0c sub $0xc,%esp 1072e1: 8b 7d 08 mov 0x8(%ebp),%edi 1072e4: ff 05 64 e5 11 00 incl 0x11e564 /* * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 1072ea: e8 41 ff ff ff call 107230 /* * Validate the parameters */ if ( !size ) 1072ef: 85 ff test %edi,%edi 1072f1: 74 5d je 107350 <== NEVER TAKEN return (void *) 0; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 1072f3: 83 3d 24 e8 11 00 03 cmpl $0x3,0x11e824 1072fa: 74 4b je 107347 * 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 ); 1072fc: 83 ec 08 sub $0x8,%esp 1072ff: 57 push %edi 107300: 68 00 e5 11 00 push $0x11e500 107305: e8 52 4a 00 00 call 10bd5c <_Protected_heap_Allocate> 10730a: 89 c3 mov %eax,%ebx if ( !return_this ) { 10730c: 83 c4 10 add $0x10,%esp 10730f: 85 c0 test %eax,%eax 107311: 74 49 je 10735c <== NEVER TAKEN if (rtems_malloc_sbrk_helpers) return_this = (*rtems_malloc_sbrk_helpers->extend)( size ); if ( !return_this ) { errno = ENOMEM; return (void *) 0; 107313: 89 c6 mov %eax,%esi } /* * If the user wants us to dirty the allocated memory, then do it. */ if ( rtems_malloc_dirty_helper ) 107315: a1 ec c9 11 00 mov 0x11c9ec,%eax 10731a: 85 c0 test %eax,%eax 10731c: 74 0a je 107328 <== ALWAYS TAKEN (*rtems_malloc_dirty_helper)( return_this, size ); 10731e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107321: 57 push %edi <== NOT EXECUTED 107322: 56 push %esi <== NOT EXECUTED 107323: ff d0 call *%eax <== NOT EXECUTED 107325: 83 c4 10 add $0x10,%esp <== NOT EXECUTED /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 107328: a1 e4 c9 11 00 mov 0x11c9e4,%eax 10732d: 85 c0 test %eax,%eax 10732f: 74 53 je 107384 <== ALWAYS TAKEN (*rtems_malloc_statistics_helpers->at_malloc)(return_this); 107331: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107334: 56 push %esi <== NOT EXECUTED 107335: ff 50 04 call *0x4(%eax) <== NOT EXECUTED 107338: 89 f3 mov %esi,%ebx <== NOT EXECUTED 10733a: 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; } 10733d: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10733f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107342: 5b pop %ebx <== NOT EXECUTED 107343: 5e pop %esi <== NOT EXECUTED 107344: 5f pop %edi <== NOT EXECUTED 107345: c9 leave <== NOT EXECUTED 107346: 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()) && 107347: e8 8c fe ff ff call 1071d8 10734c: 84 c0 test %al,%al 10734e: 75 ac jne 1072fc <== ALWAYS TAKEN /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) (*rtems_malloc_statistics_helpers->at_malloc)(return_this); 107350: 31 db xor %ebx,%ebx if (rtems_malloc_boundary_helpers) (*rtems_malloc_boundary_helpers->at_malloc)(return_this, size); #endif return return_this; } 107352: 89 d8 mov %ebx,%eax <== NOT EXECUTED 107354: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107357: 5b pop %ebx <== NOT EXECUTED 107358: 5e pop %esi <== NOT EXECUTED 107359: 5f pop %edi <== NOT EXECUTED 10735a: c9 leave <== NOT EXECUTED 10735b: c3 ret <== NOT EXECUTED */ return_this = _Protected_heap_Allocate( &RTEMS_Malloc_Heap, size ); if ( !return_this ) { if (rtems_malloc_sbrk_helpers) 10735c: a1 e8 c9 11 00 mov 0x11c9e8,%eax <== NOT EXECUTED 107361: 85 c0 test %eax,%eax <== NOT EXECUTED 107363: 74 10 je 107375 <== NOT EXECUTED return_this = (*rtems_malloc_sbrk_helpers->extend)( size ); 107365: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107368: 57 push %edi <== NOT EXECUTED 107369: ff 50 04 call *0x4(%eax) <== NOT EXECUTED 10736c: 89 c6 mov %eax,%esi <== NOT EXECUTED if ( !return_this ) { 10736e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107371: 85 c0 test %eax,%eax <== NOT EXECUTED 107373: 75 a0 jne 107315 <== NOT EXECUTED errno = ENOMEM; 107375: e8 a6 8e 00 00 call 110220 <__errno> <== NOT EXECUTED 10737a: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 107380: eb bb jmp 10733d <== NOT EXECUTED 107382: 66 90 xchg %ax,%ax <== NOT EXECUTED (*rtems_malloc_dirty_helper)( return_this, size ); /* * If configured, update the statistics */ if ( rtems_malloc_statistics_helpers ) 107384: 89 f3 mov %esi,%ebx if (rtems_malloc_boundary_helpers) (*rtems_malloc_boundary_helpers->at_malloc)(return_this, size); #endif return return_this; } 107386: 89 d8 mov %ebx,%eax 107388: 8d 65 f4 lea -0xc(%ebp),%esp 10738b: 5b pop %ebx 10738c: 5e pop %esi 10738d: 5f pop %edi 10738e: c9 leave 10738f: c3 ret =============================================================================== 00107218 : } void malloc_deferred_free( void *pointer ) { 107218: 55 push %ebp <== NOT EXECUTED 107219: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10721b: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 10721e: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107221: 68 dc e4 11 00 push $0x11e4dc <== NOT EXECUTED 107226: e8 51 3b 00 00 call 10ad7c <_Chain_Append> <== NOT EXECUTED 10722b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_chain_append(&RTEMS_Malloc_GC_list, (rtems_chain_node *)pointer); } 10722e: c9 leave <== NOT EXECUTED 10722f: c3 ret <== NOT EXECUTED =============================================================================== 00107230 : { rtems_chain_initialize_empty(&RTEMS_Malloc_GC_list); } void malloc_deferred_frees_process(void) { 107230: 55 push %ebp 107231: 89 e5 mov %esp,%ebp 107233: 83 ec 08 sub $0x8,%esp 107236: eb 0c jmp 107244 /* * 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); 107238: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10723b: 50 push %eax <== NOT EXECUTED 10723c: e8 7f fe ff ff call 1070c0 <== NOT EXECUTED 107241: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107244: 83 ec 0c sub $0xc,%esp 107247: 68 dc e4 11 00 push $0x11e4dc 10724c: e8 4f 3b 00 00 call 10ada0 <_Chain_Get> 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) 107251: 83 c4 10 add $0x10,%esp 107254: 85 c0 test %eax,%eax 107256: 75 e0 jne 107238 <== NEVER TAKEN free(to_be_freed); } 107258: c9 leave 107259: c3 ret =============================================================================== 00108618 : */ int malloc_info( Heap_Information_block *the_info ) { 108618: 55 push %ebp 108619: 89 e5 mov %esp,%ebp 10861b: 83 ec 08 sub $0x8,%esp 10861e: 8b 45 08 mov 0x8(%ebp),%eax if ( !the_info ) 108621: 85 c0 test %eax,%eax 108623: 74 17 je 10863c return -1; _Protected_heap_Get_information( &RTEMS_Malloc_Heap, the_info ); 108625: 83 ec 08 sub $0x8,%esp 108628: 50 push %eax 108629: 68 a0 3b 12 00 push $0x123ba0 10862e: e8 0d 57 00 00 call 10dd40 <_Protected_heap_Get_information> 108633: 31 c0 xor %eax,%eax 108635: 83 c4 10 add $0x10,%esp return 0; } 108638: c9 leave 108639: c3 ret 10863a: 66 90 xchg %ax,%ax int malloc_info( Heap_Information_block *the_info ) { if ( !the_info ) 10863c: b8 ff ff ff ff mov $0xffffffff,%eax return -1; _Protected_heap_Get_information( &RTEMS_Malloc_Heap, the_info ); return 0; } 108641: c9 leave 108642: c3 ret =============================================================================== 001071d8 : #include "malloc_p.h" rtems_chain_control RTEMS_Malloc_GC_list; bool malloc_is_system_state_OK(void) { 1071d8: 55 push %ebp 1071d9: 89 e5 mov %esp,%ebp if ( _Thread_Dispatch_disable_level > 0 ) 1071db: a1 58 e6 11 00 mov 0x11e658,%eax 1071e0: 85 c0 test %eax,%eax 1071e2: 75 0c jne 1071f0 <== NEVER TAKEN return false; if ( _ISR_Nest_level > 0 ) 1071e4: a1 f8 e6 11 00 mov 0x11e6f8,%eax 1071e9: 85 c0 test %eax,%eax 1071eb: 0f 94 c0 sete %al return false; return true; } 1071ee: c9 leave 1071ef: c3 ret rtems_chain_control RTEMS_Malloc_GC_list; bool malloc_is_system_state_OK(void) { if ( _Thread_Dispatch_disable_level > 0 ) 1071f0: 31 c0 xor %eax,%eax if ( _ISR_Nest_level > 0 ) return false; return true; } 1071f2: c9 leave <== NOT EXECUTED 1071f3: c3 ret <== NOT EXECUTED =============================================================================== 00107390 : int mknod( const char *pathname, mode_t mode, dev_t dev ) { 107390: 55 push %ebp 107391: 89 e5 mov %esp,%ebp 107393: 57 push %edi 107394: 56 push %esi 107395: 53 push %ebx 107396: 83 ec 3c sub $0x3c,%esp 107399: 8b 5d 08 mov 0x8(%ebp),%ebx 10739c: 8b 45 10 mov 0x10(%ebp),%eax 10739f: 8b 55 14 mov 0x14(%ebp),%edx 1073a2: 89 45 c8 mov %eax,-0x38(%ebp) 1073a5: 89 55 cc mov %edx,-0x34(%ebp) int result; /* * The file type is field within the mode. Check we have a sane mode set. */ switch (mode & S_IFMT) { 1073a8: 8b 45 0c mov 0xc(%ebp),%eax 1073ab: 25 00 f0 00 00 and $0xf000,%eax 1073b0: 3d 00 40 00 00 cmp $0x4000,%eax 1073b5: 74 35 je 1073ec 1073b7: 76 23 jbe 1073dc <== ALWAYS TAKEN 1073b9: 3d 00 60 00 00 cmp $0x6000,%eax <== NOT EXECUTED 1073be: 74 2c je 1073ec <== NOT EXECUTED 1073c0: 3d 00 80 00 00 cmp $0x8000,%eax <== NOT EXECUTED 1073c5: 74 25 je 1073ec <== NOT EXECUTED case S_IFBLK: case S_IFREG: case S_IFIFO: break; default: rtems_set_errno_and_return_minus_one( EINVAL ); 1073c7: e8 54 8e 00 00 call 110220 <__errno> <== NOT EXECUTED 1073cc: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 1073d2: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 1073d7: eb 5b jmp 107434 <== NOT EXECUTED 1073d9: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED int result; /* * The file type is field within the mode. Check we have a sane mode set. */ switch (mode & S_IFMT) { 1073dc: 3d 00 10 00 00 cmp $0x1000,%eax 1073e1: 74 41 je 107424 <== NEVER TAKEN 1073e3: 3d 00 20 00 00 cmp $0x2000,%eax 1073e8: 75 dd jne 1073c7 <== NEVER TAKEN 1073ea: 66 90 xchg %ax,%ax break; default: rtems_set_errno_and_return_minus_one( EINVAL ); } if ( S_ISFIFO(mode) ) 1073ec: 3d 00 10 00 00 cmp $0x1000,%eax 1073f1: 74 31 je 107424 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); rtems_filesystem_get_start_loc( pathname, &i, &temp_loc ); 1073f3: 8a 03 mov (%ebx),%al 1073f5: 3c 2f cmp $0x2f,%al 1073f7: 74 47 je 107440 <== ALWAYS TAKEN 1073f9: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 1073fb: 74 43 je 107440 <== NOT EXECUTED 1073fd: 84 c0 test %al,%al <== NOT EXECUTED 1073ff: 74 3f je 107440 <== NOT EXECUTED 107401: 8d 45 dc lea -0x24(%ebp),%eax <== NOT EXECUTED 107404: 89 45 bc mov %eax,-0x44(%ebp) <== NOT EXECUTED 107407: a1 b4 c4 11 00 mov 0x11c4b4,%eax <== NOT EXECUTED 10740c: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 10740f: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 107414: 8b 7d bc mov -0x44(%ebp),%edi <== NOT EXECUTED 107417: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED if ( !temp_loc.ops->evalformake_h ) { 107419: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10741c: 8b 50 04 mov 0x4(%eax),%edx <== NOT EXECUTED 10741f: 85 d2 test %edx,%edx <== NOT EXECUTED 107421: 75 40 jne 107463 <== NOT EXECUTED 107423: 90 nop <== 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 ); 107424: e8 f7 8d 00 00 call 110220 <__errno> <== NOT EXECUTED 107429: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10742f: 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; } 107434: 89 f0 mov %esi,%eax 107436: 8d 65 f4 lea -0xc(%ebp),%esp 107439: 5b pop %ebx 10743a: 5e pop %esi 10743b: 5f pop %edi 10743c: c9 leave 10743d: c3 ret 10743e: 66 90 xchg %ax,%ax } if ( S_ISFIFO(mode) ) rtems_set_errno_and_return_minus_one( ENOTSUP ); rtems_filesystem_get_start_loc( pathname, &i, &temp_loc ); 107440: 8d 55 dc lea -0x24(%ebp),%edx 107443: 89 55 bc mov %edx,-0x44(%ebp) 107446: a1 b4 c4 11 00 mov 0x11c4b4,%eax 10744b: 8d 70 14 lea 0x14(%eax),%esi 10744e: b9 04 00 00 00 mov $0x4,%ecx 107453: 89 d7 mov %edx,%edi 107455: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 107457: b1 01 mov $0x1,%cl if ( !temp_loc.ops->evalformake_h ) { 107459: 8b 45 e4 mov -0x1c(%ebp),%eax 10745c: 8b 50 04 mov 0x4(%eax),%edx 10745f: 85 d2 test %edx,%edx 107461: 74 c1 je 107424 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); } result = (*temp_loc.ops->evalformake_h)( 107463: 50 push %eax 107464: 8d 45 ec lea -0x14(%ebp),%eax 107467: 50 push %eax 107468: ff 75 bc pushl -0x44(%ebp) 10746b: 8d 04 0b lea (%ebx,%ecx,1),%eax 10746e: 50 push %eax 10746f: ff d2 call *%edx &pathname[i], &temp_loc, &name_start ); if ( result != 0 ) 107471: 83 c4 10 add $0x10,%esp 107474: 85 c0 test %eax,%eax 107476: 75 b7 jne 10742f <== NEVER TAKEN return -1; if ( !temp_loc.ops->mknod_h ) { 107478: 8b 45 e4 mov -0x1c(%ebp),%eax 10747b: 8b 50 14 mov 0x14(%eax),%edx 10747e: 85 d2 test %edx,%edx 107480: 74 3c je 1074be <== NEVER TAKEN 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 ); 107482: 83 ec 0c sub $0xc,%esp 107485: ff 75 bc pushl -0x44(%ebp) 107488: ff 75 cc pushl -0x34(%ebp) 10748b: ff 75 c8 pushl -0x38(%ebp) 10748e: ff 75 0c pushl 0xc(%ebp) 107491: ff 75 ec pushl -0x14(%ebp) 107494: ff d2 call *%edx 107496: 89 c6 mov %eax,%esi rtems_filesystem_freenode( &temp_loc ); 107498: 8b 45 e4 mov -0x1c(%ebp),%eax 10749b: 83 c4 20 add $0x20,%esp 10749e: 85 c0 test %eax,%eax 1074a0: 74 92 je 107434 <== NEVER TAKEN 1074a2: 8b 40 1c mov 0x1c(%eax),%eax 1074a5: 85 c0 test %eax,%eax 1074a7: 74 8b je 107434 <== ALWAYS TAKEN 1074a9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1074ac: ff 75 bc pushl -0x44(%ebp) <== NOT EXECUTED 1074af: ff d0 call *%eax <== NOT EXECUTED 1074b1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 1074b4: 89 f0 mov %esi,%eax <== NOT EXECUTED 1074b6: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1074b9: 5b pop %ebx <== NOT EXECUTED 1074ba: 5e pop %esi <== NOT EXECUTED 1074bb: 5f pop %edi <== NOT EXECUTED 1074bc: c9 leave <== NOT EXECUTED 1074bd: c3 ret <== NOT EXECUTED ); if ( result != 0 ) return -1; if ( !temp_loc.ops->mknod_h ) { rtems_filesystem_freenode( &temp_loc ); 1074be: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 1074c1: 85 c0 test %eax,%eax <== NOT EXECUTED 1074c3: 0f 84 5b ff ff ff je 107424 <== NOT EXECUTED 1074c9: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1074cc: ff 75 bc pushl -0x44(%ebp) <== NOT EXECUTED 1074cf: ff d0 call *%eax <== NOT EXECUTED 1074d1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1074d4: e9 4b ff ff ff jmp 107424 <== NOT EXECUTED =============================================================================== 0010e964 : const rtems_filesystem_operations_table *fs_ops, rtems_filesystem_options_t options, const char *device, const char *mount_point ) { 10e964: 55 push %ebp 10e965: 89 e5 mov %esp,%ebp 10e967: 57 push %edi 10e968: 56 push %esi 10e969: 53 push %ebx 10e96a: 83 ec 1c sub $0x1c,%esp 10e96d: 8b 75 10 mov 0x10(%ebp),%esi /* * Is there a file system operations table? */ if ( fs_ops == NULL ) { 10e970: 8b 45 0c mov 0xc(%ebp),%eax 10e973: 85 c0 test %eax,%eax 10e975: 0f 84 75 02 00 00 je 10ebf0 <== NEVER TAKEN /* * Are the file system options valid? */ if ( options != RTEMS_FILESYSTEM_READ_ONLY && 10e97b: 83 fe 01 cmp $0x1,%esi 10e97e: 0f 87 6c 02 00 00 ja 10ebf0 <== NEVER TAKEN errno = EINVAL; return -1; } /* Do they support being mounted at all ? */ if ( !fs_ops->fsmount_me_h ) { 10e984: 8b 45 0c mov 0xc(%ebp),%eax 10e987: 8b 78 24 mov 0x24(%eax),%edi 10e98a: 85 ff test %edi,%edi 10e98c: 0f 84 cb 00 00 00 je 10ea5d <== NEVER TAKEN /* * Allocate a mount table entry */ size = sizeof(rtems_filesystem_mount_table_entry_t); if ( device ) 10e992: 8b 5d 14 mov 0x14(%ebp),%ebx 10e995: 85 db test %ebx,%ebx 10e997: 0f 84 ef 00 00 00 je 10ea8c <== ALWAYS TAKEN size += strlen( device ) + 1; 10e99d: 31 c0 xor %eax,%eax 10e99f: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 10e9a4: 8b 7d 14 mov 0x14(%ebp),%edi <== NOT EXECUTED 10e9a7: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 10e9a9: f7 d1 not %ecx <== NOT EXECUTED 10e9ab: 8d 41 64 lea 0x64(%ecx),%eax <== NOT EXECUTED temp_mt_entry = malloc( size ); 10e9ae: 83 ec 0c sub $0xc,%esp 10e9b1: 50 push %eax 10e9b2: e8 21 89 ff ff call 1072d8 10e9b7: 89 c3 mov %eax,%ebx 10e9b9: 89 45 e0 mov %eax,-0x20(%ebp) if ( !temp_mt_entry ) { 10e9bc: 83 c4 10 add $0x10,%esp 10e9bf: 85 c0 test %eax,%eax 10e9c1: 0f 84 3e 02 00 00 je 10ec05 <== NEVER TAKEN errno = ENOMEM; return -1; } temp_mt_entry->mt_fs_root.mt_entry = temp_mt_entry; 10e9c7: 89 43 24 mov %eax,0x24(%ebx) temp_mt_entry->options = options; 10e9ca: 89 70 28 mov %esi,0x28(%eax) if ( device ) { 10e9cd: 8b 4d 14 mov 0x14(%ebp),%ecx 10e9d0: 85 c9 test %ecx,%ecx 10e9d2: 0f 84 3c 01 00 00 je 10eb14 <== ALWAYS TAKEN temp_mt_entry->dev = 10e9d8: 8d 40 64 lea 0x64(%eax),%eax <== NOT EXECUTED 10e9db: 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 ); 10e9de: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e9e1: ff 75 14 pushl 0x14(%ebp) <== NOT EXECUTED 10e9e4: 50 push %eax <== NOT EXECUTED 10e9e5: e8 42 29 00 00 call 11132c <== NOT EXECUTED 10e9ea: 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 ) { 10e9ed: 8b 55 18 mov 0x18(%ebp),%edx 10e9f0: 85 d2 test %edx,%edx 10e9f2: 0f 84 a0 00 00 00 je 10ea98 <== ALWAYS TAKEN if ( rtems_filesystem_evaluate_path( 10e9f8: 6a 01 push $0x1 <== NOT EXECUTED 10e9fa: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 10e9fd: 56 push %esi <== NOT EXECUTED 10e9fe: 6a 07 push $0x7 <== NOT EXECUTED 10ea00: ff 75 18 pushl 0x18(%ebp) <== NOT EXECUTED 10ea03: e8 74 85 ff ff call 106f7c <== NOT EXECUTED 10ea08: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ea0b: 40 inc %eax <== NOT EXECUTED 10ea0c: 74 62 je 10ea70 <== NOT EXECUTED /* * Test for node_type_h */ if (!loc.ops->node_type_h) { 10ea0e: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10ea11: 8b 40 10 mov 0x10(%eax),%eax <== NOT EXECUTED 10ea14: 85 c0 test %eax,%eax <== NOT EXECUTED 10ea16: 0f 84 9c 01 00 00 je 10ebb8 <== NOT EXECUTED /* * Test to see if it is a directory */ if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) { 10ea1c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ea1f: 56 push %esi <== NOT EXECUTED 10ea20: ff d0 call *%eax <== NOT EXECUTED 10ea22: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ea25: 48 dec %eax <== NOT EXECUTED 10ea26: 0f 84 f4 00 00 00 je 10eb20 <== NOT EXECUTED errno = ENOTDIR; 10ea2c: e8 ef 17 00 00 call 110220 <__errno> <== NOT EXECUTED 10ea31: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED return 0; cleanup_and_bail: free( temp_mt_entry ); 10ea37: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ea3a: 53 push %ebx <== NOT EXECUTED 10ea3b: e8 80 86 ff ff call 1070c0 <== NOT EXECUTED 10ea40: 89 f7 mov %esi,%edi <== NOT EXECUTED 10ea42: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); 10ea45: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED 10ea48: 85 c0 test %eax,%eax <== NOT EXECUTED 10ea4a: 0f 85 78 01 00 00 jne 10ebc8 <== NOT EXECUTED 10ea50: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED return -1; } 10ea55: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ea58: 5b pop %ebx <== NOT EXECUTED 10ea59: 5e pop %esi <== NOT EXECUTED 10ea5a: 5f pop %edi <== NOT EXECUTED 10ea5b: c9 leave <== NOT EXECUTED 10ea5c: c3 ret <== NOT EXECUTED return -1; } /* Do they support being mounted at all ? */ if ( !fs_ops->fsmount_me_h ) { errno = ENOTSUP; 10ea5d: e8 be 17 00 00 call 110220 <__errno> <== NOT EXECUTED 10ea62: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10ea68: c7 45 e0 00 00 00 00 movl $0x0,-0x20(%ebp) <== NOT EXECUTED 10ea6f: 90 nop <== NOT EXECUTED return 0; cleanup_and_bail: free( temp_mt_entry ); 10ea70: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ea73: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10ea76: e8 45 86 ff ff call 1070c0 <== NOT EXECUTED 10ea7b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ea80: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; } 10ea83: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10ea86: 5b pop %ebx <== NOT EXECUTED 10ea87: 5e pop %esi <== NOT EXECUTED 10ea88: 5f pop %edi <== NOT EXECUTED 10ea89: c9 leave <== NOT EXECUTED 10ea8a: c3 ret <== NOT EXECUTED 10ea8b: 90 nop <== NOT EXECUTED /* * Allocate a mount table entry */ size = sizeof(rtems_filesystem_mount_table_entry_t); if ( device ) 10ea8c: b8 64 00 00 00 mov $0x64,%eax 10ea91: e9 18 ff ff ff jmp 10e9ae 10ea96: 66 90 xchg %ax,%ax * 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; 10ea98: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) temp_mt_entry->mt_fs_root.handlers = NULL; 10ea9f: c7 43 1c 00 00 00 00 movl $0x0,0x1c(%ebx) temp_mt_entry->mt_fs_root.ops = NULL; 10eaa6: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) temp_mt_entry->mt_point_node.node_access = NULL; 10eaad: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx) temp_mt_entry->mt_point_node.handlers = NULL; 10eab4: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) temp_mt_entry->mt_point_node.ops = NULL; 10eabb: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) temp_mt_entry->mt_point_node.mt_entry = NULL; 10eac2: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) 10eac9: 31 ff xor %edi,%edi } if ( fs_ops->fsmount_me_h( temp_mt_entry ) ) { 10eacb: 83 ec 0c sub $0xc,%esp 10eace: 53 push %ebx 10eacf: 8b 55 0c mov 0xc(%ebp),%edx 10ead2: ff 52 24 call *0x24(%edx) 10ead5: 83 c4 10 add $0x10,%esp 10ead8: 85 c0 test %eax,%eax 10eada: 0f 84 a0 00 00 00 je 10eb80 <== ALWAYS TAKEN /* try to undo the mount operation */ if ( loc.ops->unmount_h ) { 10eae0: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10eae3: 8b 40 28 mov 0x28(%eax),%eax <== NOT EXECUTED 10eae6: 85 c0 test %eax,%eax <== NOT EXECUTED 10eae8: 74 09 je 10eaf3 <== NOT EXECUTED loc.ops->unmount_h( temp_mt_entry ); 10eaea: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eaed: 53 push %ebx <== NOT EXECUTED 10eaee: ff d0 call *%eax <== NOT EXECUTED 10eaf0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; cleanup_and_bail: free( temp_mt_entry ); 10eaf3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eaf6: 53 push %ebx <== NOT EXECUTED 10eaf7: e8 c4 85 ff ff call 1070c0 <== NOT EXECUTED if ( loc_to_free ) 10eafc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eaff: 85 ff test %edi,%edi <== NOT EXECUTED 10eb01: 0f 85 3e ff ff ff jne 10ea45 <== NOT EXECUTED rtems_filesystem_freenode( loc_to_free ); 10eb07: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10eb0c: e9 44 ff ff ff jmp 10ea55 <== NOT EXECUTED 10eb11: 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; 10eb14: c7 40 60 00 00 00 00 movl $0x0,0x60(%eax) 10eb1b: e9 cd fe ff ff jmp 10e9ed /* * For each mount table entry */ for ( the_node = rtems_filesystem_mount_table_control.first; 10eb20: a1 60 e9 11 00 mov 0x11e960,%eax <== NOT EXECUTED !rtems_chain_is_tail( &rtems_filesystem_mount_table_control, the_node ); 10eb25: 3d 64 e9 11 00 cmp $0x11e964,%eax <== NOT EXECUTED 10eb2a: 0f 84 b6 00 00 00 je 10ebe6 <== 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 ) 10eb30: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10eb33: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED 10eb36: 75 09 jne 10eb41 <== NOT EXECUTED 10eb38: eb 6e jmp 10eba8 <== NOT EXECUTED 10eb3a: 66 90 xchg %ax,%ax <== NOT EXECUTED 10eb3c: 39 50 18 cmp %edx,0x18(%eax) <== NOT EXECUTED 10eb3f: 74 67 je 10eba8 <== 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 ) { 10eb41: 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 ); 10eb43: 3d 64 e9 11 00 cmp $0x11e964,%eax <== NOT EXECUTED 10eb48: 75 f2 jne 10eb3c <== 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; 10eb4a: 89 53 08 mov %edx,0x8(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.handlers = loc.handlers; 10eb4d: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 10eb50: 89 43 0c mov %eax,0xc(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.ops = loc.ops; 10eb53: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 10eb56: 89 53 10 mov %edx,0x10(%ebx) <== NOT EXECUTED temp_mt_entry->mt_point_node.mt_entry = loc.mt_entry; 10eb59: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 10eb5c: 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 ){ 10eb5f: 8b 42 20 mov 0x20(%edx),%eax <== NOT EXECUTED 10eb62: 85 c0 test %eax,%eax <== NOT EXECUTED 10eb64: 74 52 je 10ebb8 <== NOT EXECUTED errno = ENOTSUP; goto cleanup_and_bail; } if ( loc.ops->mount_h( temp_mt_entry ) ) { 10eb66: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10eb69: 53 push %ebx <== NOT EXECUTED 10eb6a: ff d0 call *%eax <== NOT EXECUTED 10eb6c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10eb6f: 85 c0 test %eax,%eax <== NOT EXECUTED 10eb71: 0f 85 c0 fe ff ff jne 10ea37 <== NOT EXECUTED goto cleanup_and_bail; 10eb77: 89 f7 mov %esi,%edi <== NOT EXECUTED 10eb79: e9 4d ff ff ff jmp 10eacb <== NOT EXECUTED 10eb7e: 66 90 xchg %ax,%ax <== NOT EXECUTED 10eb80: 83 ec 08 sub $0x8,%esp 10eb83: 53 push %ebx 10eb84: 68 60 e9 11 00 push $0x11e960 10eb89: e8 ee c1 ff ff call 10ad7c <_Chain_Append> */ rtems_chain_append( &rtems_filesystem_mount_table_control, &temp_mt_entry->Node ); if ( mt_entry ) 10eb8e: 83 c4 10 add $0x10,%esp 10eb91: 8b 45 08 mov 0x8(%ebp),%eax 10eb94: 85 c0 test %eax,%eax 10eb96: 74 05 je 10eb9d <== NEVER TAKEN *mt_entry = temp_mt_entry; 10eb98: 8b 7d 08 mov 0x8(%ebp),%edi 10eb9b: 89 1f mov %ebx,(%edi) 10eb9d: 31 c0 xor %eax,%eax if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); return -1; } 10eb9f: 8d 65 f4 lea -0xc(%ebp),%esp 10eba2: 5b pop %ebx 10eba3: 5e pop %esi 10eba4: 5f pop %edi 10eba5: c9 leave 10eba6: c3 ret 10eba7: 90 nop /* * You can only mount one file system onto a single mount point. */ if ( Is_node_fs_root( &loc ) ){ errno = EBUSY; 10eba8: e8 73 16 00 00 call 110220 <__errno> <== NOT EXECUTED 10ebad: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED 10ebb3: e9 7f fe ff ff jmp 10ea37 <== 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; 10ebb8: e8 63 16 00 00 call 110220 <__errno> <== NOT EXECUTED 10ebbd: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10ebc3: e9 6f fe ff ff jmp 10ea37 <== NOT EXECUTED cleanup_and_bail: free( temp_mt_entry ); if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); 10ebc8: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10ebcb: 85 c0 test %eax,%eax <== NOT EXECUTED 10ebcd: 0f 84 7d fe ff ff je 10ea50 <== NOT EXECUTED 10ebd3: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10ebd6: 57 push %edi <== NOT EXECUTED 10ebd7: ff d0 call *%eax <== NOT EXECUTED 10ebd9: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ebde: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10ebe1: e9 9d fe ff ff jmp 10ea83 <== NOT EXECUTED 10ebe6: 8b 55 e4 mov -0x1c(%ebp),%edx <== NOT EXECUTED 10ebe9: e9 5c ff ff ff jmp 10eb4a <== NOT EXECUTED 10ebee: 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; 10ebf0: e8 2b 16 00 00 call 110220 <__errno> <== NOT EXECUTED 10ebf5: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 10ebfb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ec00: e9 7e fe ff ff jmp 10ea83 <== NOT EXECUTED if ( device ) size += strlen( device ) + 1; temp_mt_entry = malloc( size ); if ( !temp_mt_entry ) { errno = ENOMEM; 10ec05: e8 16 16 00 00 call 110220 <__errno> <== NOT EXECUTED 10ec0a: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED 10ec10: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10ec15: e9 69 fe ff ff jmp 10ea83 <== NOT EXECUTED =============================================================================== 00107568 : */ int newlib_free_buffers( FILE *fp ) { 107568: 55 push %ebp 107569: 89 e5 mov %esp,%ebp 10756b: 53 push %ebx 10756c: 83 ec 10 sub $0x10,%esp 10756f: 8b 5d 08 mov 0x8(%ebp),%ebx switch ( fileno(fp) ) { 107572: 53 push %ebx 107573: e8 94 8f 00 00 call 11050c 107578: 83 c4 10 add $0x10,%esp 10757b: 83 f8 02 cmp $0x2,%eax 10757e: 76 14 jbe 107594 <== ALWAYS TAKEN fp->_flags &= ~__SMBF; fp->_bf._base = fp->_p = (unsigned char *) NULL; } break; default: fclose(fp); 107580: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107583: 53 push %ebx <== NOT EXECUTED 107584: e8 e3 8d 00 00 call 11036c <== NOT EXECUTED 107589: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } return 0; } 10758c: 31 c0 xor %eax,%eax 10758e: 8b 5d fc mov -0x4(%ebp),%ebx 107591: c9 leave 107592: c3 ret 107593: 90 nop { switch ( fileno(fp) ) { case 0: case 1: case 2: if (fp->_flags & __SMBF) { 107594: 80 7b 0c 00 cmpb $0x0,0xc(%ebx) 107598: 79 f2 jns 10758c free( fp->_bf._base ); 10759a: 83 ec 0c sub $0xc,%esp 10759d: ff 73 10 pushl 0x10(%ebx) 1075a0: e8 1b fb ff ff call 1070c0 fp->_flags &= ~__SMBF; 1075a5: 66 81 63 0c 7f ff andw $0xff7f,0xc(%ebx) fp->_bf._base = fp->_p = (unsigned char *) NULL; 1075ab: c7 03 00 00 00 00 movl $0x0,(%ebx) 1075b1: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) 1075b8: 83 c4 10 add $0x10,%esp break; default: fclose(fp); } return 0; } 1075bb: 31 c0 xor %eax,%eax 1075bd: 8b 5d fc mov -0x4(%ebp),%ebx 1075c0: c9 leave 1075c1: c3 ret =============================================================================== 001076fc : rtems_device_driver null_initialize( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 1076fc: 55 push %ebp 1076fd: 89 e5 mov %esp,%ebp 1076ff: 83 ec 08 sub $0x8,%esp rtems_device_driver status; if ( !initialized ) { 107702: 80 3d 50 13 12 00 00 cmpb $0x0,0x121350 107709: 74 05 je 107710 NULL_major = major; } return RTEMS_SUCCESSFUL; } 10770b: 31 c0 xor %eax,%eax 10770d: c9 leave 10770e: c3 ret 10770f: 90 nop ) { rtems_device_driver status; if ( !initialized ) { initialized = 1; 107710: c6 05 50 13 12 00 01 movb $0x1,0x121350 status = rtems_io_register_name( 107717: 50 push %eax 107718: 6a 00 push $0x0 10771a: ff 75 08 pushl 0x8(%ebp) 10771d: 68 b7 ac 11 00 push $0x11acb7 107722: e8 11 01 00 00 call 107838 "/dev/null", major, (rtems_device_minor_number) 0 ); if (status != RTEMS_SUCCESSFUL) 107727: 83 c4 10 add $0x10,%esp 10772a: 85 c0 test %eax,%eax 10772c: 75 0c jne 10773a <== NEVER TAKEN rtems_fatal_error_occurred(status); NULL_major = major; 10772e: 8b 45 08 mov 0x8(%ebp),%eax 107731: a3 90 15 12 00 mov %eax,0x121590 } return RTEMS_SUCCESSFUL; } 107736: 31 c0 xor %eax,%eax 107738: c9 leave 107739: c3 ret major, (rtems_device_minor_number) 0 ); if (status != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred(status); 10773a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10773d: 50 push %eax <== NOT EXECUTED 10773e: e8 81 3f 00 00 call 10b6c4 <== NOT EXECUTED =============================================================================== 001076e0 : rtems_device_driver null_write( rtems_device_major_number major, rtems_device_minor_number minor, void *pargp ) { 1076e0: 55 push %ebp 1076e1: 89 e5 mov %esp,%ebp 1076e3: 8b 55 10 mov 0x10(%ebp),%edx rtems_libio_rw_args_t *rw_args = (rtems_libio_rw_args_t *) pargp; if ( rw_args ) 1076e6: 85 d2 test %edx,%edx 1076e8: 74 06 je 1076f0 <== ALWAYS TAKEN rw_args->bytes_moved = rw_args->count; 1076ea: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 1076ed: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED return NULL_SUCCESSFUL; } 1076f0: 31 c0 xor %eax,%eax 1076f2: c9 leave 1076f3: c3 ret =============================================================================== 00107880 : int open( const char *pathname, int flags, ... ) { 107880: 55 push %ebp 107881: 89 e5 mov %esp,%ebp 107883: 57 push %edi 107884: 56 push %esi 107885: 53 push %ebx 107886: 83 ec 2c sub $0x2c,%esp /* * Set the Evaluation flags */ eval_flags = 0; status = flags + 1; 107889: 8b 45 0c mov 0xc(%ebp),%eax 10788c: 40 inc %eax if ( ( status & _FREAD ) == _FREAD ) 10788d: 89 c3 mov %eax,%ebx 10788f: 83 e3 01 and $0x1,%ebx 107892: f7 db neg %ebx 107894: 83 e3 04 and $0x4,%ebx eval_flags |= RTEMS_LIBIO_PERMS_READ; if ( ( status & _FWRITE ) == _FWRITE ) 107897: a8 02 test $0x2,%al 107899: 74 03 je 10789e eval_flags |= RTEMS_LIBIO_PERMS_WRITE; 10789b: 83 cb 02 or $0x2,%ebx va_start(ap, flags); mode = va_arg( ap, int ); 10789e: 8b 45 10 mov 0x10(%ebp),%eax 1078a1: 89 45 e0 mov %eax,-0x20(%ebp) * 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(); 1078a4: e8 83 6f 00 00 call 10e82c 1078a9: 89 45 d4 mov %eax,-0x2c(%ebp) if ( iop == 0 ) { 1078ac: 85 c0 test %eax,%eax 1078ae: 0f 84 bc 00 00 00 je 107970 /* * See if the file exists. */ status = rtems_filesystem_evaluate_path( 1078b4: 6a 01 push $0x1 1078b6: 8d 55 e4 lea -0x1c(%ebp),%edx 1078b9: 89 55 d8 mov %edx,-0x28(%ebp) 1078bc: 52 push %edx 1078bd: 53 push %ebx 1078be: ff 75 08 pushl 0x8(%ebp) 1078c1: e8 b6 f6 ff ff call 106f7c pathname, eval_flags, &loc, true ); if ( status == -1 ) { 1078c6: 83 c4 10 add $0x10,%esp 1078c9: 40 inc %eax 1078ca: 0f 84 14 01 00 00 je 1079e4 <== NEVER TAKEN if ( status != 0 ) { /* The file did not exist */ rc = EACCES; goto done; } } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) { 1078d0: 8b 45 0c mov 0xc(%ebp),%eax 1078d3: 25 00 0a 00 00 and $0xa00,%eax 1078d8: 3d 00 0a 00 00 cmp $0xa00,%eax 1078dd: 0f 84 a9 00 00 00 je 10798c <== NEVER TAKEN /* * Fill in the file control block based on the loc structure * returned by successful path evaluation. */ iop->handlers = loc.handlers; 1078e3: 8b 45 e8 mov -0x18(%ebp),%eax 1078e6: 8b 55 d4 mov -0x2c(%ebp),%edx 1078e9: 89 42 30 mov %eax,0x30(%edx) iop->file_info = loc.node_access; 1078ec: 8b 45 e4 mov -0x1c(%ebp),%eax 1078ef: 89 42 2c mov %eax,0x2c(%edx) iop->flags |= rtems_libio_fcntl_flags( flags ); 1078f2: 8b 5a 0c mov 0xc(%edx),%ebx 1078f5: 83 ec 0c sub $0xc,%esp 1078f8: ff 75 0c pushl 0xc(%ebp) 1078fb: e8 e8 6f 00 00 call 10e8e8 107900: 09 c3 or %eax,%ebx 107902: 8b 75 d4 mov -0x2c(%ebp),%esi 107905: 89 5e 0c mov %ebx,0xc(%esi) iop->pathinfo = loc; 107908: 89 f7 mov %esi,%edi 10790a: 83 c7 10 add $0x10,%edi 10790d: b9 04 00 00 00 mov $0x4,%ecx 107912: 8b 75 d8 mov -0x28(%ebp),%esi 107915: f3 a5 rep movsl %ds:(%esi),%es:(%edi) if ( !iop->handlers->open_h ) { 107917: 8b 55 d4 mov -0x2c(%ebp),%edx 10791a: 8b 42 30 mov 0x30(%edx),%eax 10791d: 8b 00 mov (%eax),%eax 10791f: 83 c4 10 add $0x10,%esp 107922: 85 c0 test %eax,%eax 107924: 0f 84 d6 00 00 00 je 107a00 <== NEVER TAKEN rc = ENOTSUP; goto done; } rc = (*iop->handlers->open_h)( iop, pathname, flags, mode ); 10792a: ff 75 e0 pushl -0x20(%ebp) 10792d: ff 75 0c pushl 0xc(%ebp) 107930: ff 75 08 pushl 0x8(%ebp) 107933: 52 push %edx 107934: ff d0 call *%eax 107936: 89 c7 mov %eax,%edi if ( rc ) 107938: 83 c4 10 add $0x10,%esp 10793b: 85 c0 test %eax,%eax 10793d: 74 61 je 1079a0 <== ALWAYS TAKEN 10793f: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED done: va_end(ap); if ( rc ) { if ( iop ) rtems_libio_free( iop ); 107942: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107945: ff 75 d4 pushl -0x2c(%ebp) <== NOT EXECUTED 107948: e8 87 6e 00 00 call 10e7d4 <== NOT EXECUTED 10794d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED if ( loc_to_free ) 107950: 85 db test %ebx,%ebx <== NOT EXECUTED 107952: 74 21 je 107975 <== NOT EXECUTED rtems_filesystem_freenode( loc_to_free ); 107954: 8b 43 08 mov 0x8(%ebx),%eax <== NOT EXECUTED 107957: 85 c0 test %eax,%eax <== NOT EXECUTED 107959: 74 1a je 107975 <== NOT EXECUTED 10795b: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 10795e: 85 c0 test %eax,%eax <== NOT EXECUTED 107960: 74 13 je 107975 <== NOT EXECUTED 107962: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107965: 53 push %ebx <== NOT EXECUTED 107966: ff d0 call *%eax <== NOT EXECUTED 107968: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10796b: eb 08 jmp 107975 <== NOT EXECUTED 10796d: 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 ) { 107970: bf 17 00 00 00 mov $0x17,%edi 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 ); 107975: e8 a6 88 00 00 call 110220 <__errno> 10797a: 89 38 mov %edi,(%eax) 10797c: b8 ff ff ff ff mov $0xffffffff,%eax } return iop - rtems_libio_iops; } 107981: 8d 65 f4 lea -0xc(%ebp),%esp 107984: 5b pop %ebx 107985: 5e pop %esi 107986: 5f pop %edi 107987: c9 leave 107988: c3 ret 107989: 8d 76 00 lea 0x0(%esi),%esi if ( status != 0 ) { /* The file did not exist */ rc = EACCES; goto done; } } else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) { 10798c: bf 11 00 00 00 mov $0x11,%edi <== NOT EXECUTED 107991: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED done: va_end(ap); if ( rc ) { if ( iop ) 107994: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 107997: 85 c0 test %eax,%eax <== NOT EXECUTED 107999: 74 b5 je 107950 <== NOT EXECUTED 10799b: eb a5 jmp 107942 <== NOT EXECUTED 10799d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED /* * Optionally truncate the file. */ if ( (flags & O_TRUNC) == O_TRUNC ) { 1079a0: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 1079a7: 0f 85 b7 00 00 00 jne 107a64 <== NEVER TAKEN if ( loc_to_free ) rtems_filesystem_freenode( loc_to_free ); rtems_set_errno_and_return_minus_one( rc ); } return iop - rtems_libio_iops; 1079ad: 8b 4d d4 mov -0x2c(%ebp),%ecx 1079b0: 2b 0d d0 e4 11 00 sub 0x11e4d0,%ecx 1079b6: c1 f9 02 sar $0x2,%ecx 1079b9: 8d 14 89 lea (%ecx,%ecx,4),%edx 1079bc: 8d 14 92 lea (%edx,%edx,4),%edx 1079bf: 89 d0 mov %edx,%eax 1079c1: c1 e0 06 shl $0x6,%eax 1079c4: 29 d0 sub %edx,%eax 1079c6: 89 c2 mov %eax,%edx 1079c8: c1 e2 0c shl $0xc,%edx 1079cb: 01 d0 add %edx,%eax 1079cd: 8d 04 81 lea (%ecx,%eax,4),%eax 1079d0: 8d 04 41 lea (%ecx,%eax,2),%eax 1079d3: c1 e0 04 shl $0x4,%eax 1079d6: 01 c8 add %ecx,%eax 1079d8: 8d 04 81 lea (%ecx,%eax,4),%eax } 1079db: 8d 65 f4 lea -0xc(%ebp),%esp 1079de: 5b pop %ebx 1079df: 5e pop %esi 1079e0: 5f pop %edi 1079e1: c9 leave 1079e2: c3 ret 1079e3: 90 nop status = rtems_filesystem_evaluate_path( pathname, eval_flags, &loc, true ); if ( status == -1 ) { if ( errno != ENOENT ) { 1079e4: e8 37 88 00 00 call 110220 <__errno> <== NOT EXECUTED 1079e9: 83 38 02 cmpl $0x2,(%eax) <== NOT EXECUTED 1079ec: 75 1e jne 107a0c <== 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) ) { 1079ee: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) <== NOT EXECUTED 1079f5: 75 29 jne 107a20 <== NOT EXECUTED 1079f7: bf 02 00 00 00 mov $0x2,%edi <== NOT EXECUTED 1079fc: 31 db xor %ebx,%ebx <== NOT EXECUTED 1079fe: eb 94 jmp 107994 <== 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; 107a00: bf 86 00 00 00 mov $0x86,%edi <== NOT EXECUTED 107a05: 8d 5d e4 lea -0x1c(%ebp),%ebx <== NOT EXECUTED 107a08: eb 8a jmp 107994 <== NOT EXECUTED 107a0a: 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; 107a0c: e8 0f 88 00 00 call 110220 <__errno> <== NOT EXECUTED 107a11: 8b 38 mov (%eax),%edi <== NOT EXECUTED */ done: va_end(ap); if ( rc ) { 107a13: 85 ff test %edi,%edi <== NOT EXECUTED 107a15: 74 96 je 1079ad <== NOT EXECUTED 107a17: 31 db xor %ebx,%ebx <== NOT EXECUTED 107a19: e9 76 ff ff ff jmp 107994 <== NOT EXECUTED 107a1e: 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 ); 107a20: 6a 00 push $0x0 <== NOT EXECUTED 107a22: 6a 00 push $0x0 <== NOT EXECUTED 107a24: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 107a27: 80 cc 80 or $0x80,%ah <== NOT EXECUTED 107a2a: 50 push %eax <== NOT EXECUTED 107a2b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107a2e: e8 5d f9 ff ff call 107390 <== NOT EXECUTED if ( rc ) { 107a33: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107a36: 85 c0 test %eax,%eax <== NOT EXECUTED 107a38: 75 d2 jne 107a0c <== 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 ); 107a3a: 6a 01 push $0x1 <== NOT EXECUTED 107a3c: 8d 45 e4 lea -0x1c(%ebp),%eax <== NOT EXECUTED 107a3f: 50 push %eax <== NOT EXECUTED 107a40: 6a 00 push $0x0 <== NOT EXECUTED 107a42: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107a45: e8 32 f5 ff ff call 106f7c <== NOT EXECUTED if ( status != 0 ) { /* The file did not exist */ 107a4a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107a4d: 85 c0 test %eax,%eax <== NOT EXECUTED 107a4f: 0f 84 8e fe ff ff je 1078e3 <== NOT EXECUTED 107a55: bf 0d 00 00 00 mov $0xd,%edi <== NOT EXECUTED 107a5a: 31 db xor %ebx,%ebx <== NOT EXECUTED 107a5c: e9 33 ff ff ff jmp 107994 <== NOT EXECUTED 107a61: 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 ); 107a64: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107a67: 6a 00 push $0x0 <== NOT EXECUTED 107a69: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED 107a6c: 2b 0d d0 e4 11 00 sub 0x11e4d0,%ecx <== NOT EXECUTED 107a72: c1 f9 02 sar $0x2,%ecx <== NOT EXECUTED 107a75: 8d 14 89 lea (%ecx,%ecx,4),%edx <== NOT EXECUTED 107a78: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 107a7b: 89 d0 mov %edx,%eax <== NOT EXECUTED 107a7d: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 107a80: 29 d0 sub %edx,%eax <== NOT EXECUTED 107a82: 89 c2 mov %eax,%edx <== NOT EXECUTED 107a84: c1 e2 0c shl $0xc,%edx <== NOT EXECUTED 107a87: 01 d0 add %edx,%eax <== NOT EXECUTED 107a89: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED 107a8c: 8d 04 41 lea (%ecx,%eax,2),%eax <== NOT EXECUTED 107a8f: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 107a92: 01 c8 add %ecx,%eax <== NOT EXECUTED 107a94: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED 107a97: 50 push %eax <== NOT EXECUTED 107a98: e8 f3 6a 00 00 call 10e590 <== NOT EXECUTED 107a9d: 89 c7 mov %eax,%edi <== NOT EXECUTED if ( rc ) { 107a9f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107aa2: 85 c0 test %eax,%eax <== NOT EXECUTED 107aa4: 0f 84 03 ff ff ff je 1079ad <== NOT EXECUTED if(errno) rc = errno; 107aaa: e8 71 87 00 00 call 110220 <__errno> <== NOT EXECUTED 107aaf: 8b 10 mov (%eax),%edx <== NOT EXECUTED 107ab1: 85 d2 test %edx,%edx <== NOT EXECUTED 107ab3: 75 46 jne 107afb <== NOT EXECUTED close( iop - rtems_libio_iops ); 107ab5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107ab8: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED 107abb: 2b 0d d0 e4 11 00 sub 0x11e4d0,%ecx <== NOT EXECUTED 107ac1: c1 f9 02 sar $0x2,%ecx <== NOT EXECUTED 107ac4: 8d 14 89 lea (%ecx,%ecx,4),%edx <== NOT EXECUTED 107ac7: 8d 14 92 lea (%edx,%edx,4),%edx <== NOT EXECUTED 107aca: 89 d0 mov %edx,%eax <== NOT EXECUTED 107acc: c1 e0 06 shl $0x6,%eax <== NOT EXECUTED 107acf: 29 d0 sub %edx,%eax <== NOT EXECUTED 107ad1: 89 c2 mov %eax,%edx <== NOT EXECUTED 107ad3: c1 e2 0c shl $0xc,%edx <== NOT EXECUTED 107ad6: 01 d0 add %edx,%eax <== NOT EXECUTED 107ad8: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED 107adb: 8d 04 41 lea (%ecx,%eax,2),%eax <== NOT EXECUTED 107ade: c1 e0 04 shl $0x4,%eax <== NOT EXECUTED 107ae1: 01 c8 add %ecx,%eax <== NOT EXECUTED 107ae3: 8d 04 81 lea (%ecx,%eax,4),%eax <== NOT EXECUTED 107ae6: 50 push %eax <== NOT EXECUTED 107ae7: e8 0c 6a 00 00 call 10e4f8 <== NOT EXECUTED 107aec: c7 45 d4 00 00 00 00 movl $0x0,-0x2c(%ebp) <== NOT EXECUTED 107af3: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107af6: e9 18 ff ff ff jmp 107a13 <== NOT EXECUTED */ if ( (flags & O_TRUNC) == O_TRUNC ) { rc = ftruncate( iop - rtems_libio_iops, 0 ); if ( rc ) { if(errno) rc = errno; 107afb: e8 20 87 00 00 call 110220 <__errno> <== NOT EXECUTED 107b00: 8b 38 mov (%eax),%edi <== NOT EXECUTED 107b02: eb b1 jmp 107ab5 <== NOT EXECUTED =============================================================================== 00107820 : /* * This is a replaceable stub */ void open_dev_console(void) { 107820: 55 push %ebp 107821: 89 e5 mov %esp,%ebp 107823: 83 ec 0c sub $0xc,%esp int error_code = 'S' << 24 | 'T' << 16 | 'D' << 8; /* * Attempt to open /dev/console. */ if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) { 107826: 6a 00 push $0x0 107828: 6a 00 push $0x0 10782a: 68 b0 70 11 00 push $0x1170b0 10782f: e8 4c 00 00 00 call 107880 107834: 83 c4 10 add $0x10,%esp 107837: 40 inc %eax 107838: 74 2a je 107864 /* * 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) 10783a: 52 push %edx 10783b: 6a 00 push $0x0 10783d: 6a 01 push $0x1 10783f: 68 b0 70 11 00 push $0x1170b0 107844: e8 37 00 00 00 call 107880 107849: 83 c4 10 add $0x10,%esp 10784c: 40 inc %eax 10784d: 74 24 je 107873 <== NEVER TAKEN rtems_fatal_error_occurred( error_code | '1' ); if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1) 10784f: 50 push %eax 107850: 6a 00 push $0x0 107852: 6a 01 push $0x1 107854: 68 b0 70 11 00 push $0x1170b0 107859: e8 22 00 00 00 call 107880 10785e: 83 c4 10 add $0x10,%esp 107861: 40 inc %eax 107862: 74 02 je 107866 <== NEVER TAKEN rtems_fatal_error_occurred( error_code | '2' ); } 107864: c9 leave 107865: c3 ret */ 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' ); 107866: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107869: 68 32 44 54 53 push $0x53544432 <== NOT EXECUTED 10786e: e8 11 32 00 00 call 10aa84 <== 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' ); 107873: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107876: 68 31 44 54 53 push $0x53544431 <== NOT EXECUTED 10787b: e8 04 32 00 00 call 10aa84 <== NOT EXECUTED =============================================================================== 001086c0 : /* * Handle output processing */ static void oproc (unsigned char c, struct rtems_termios_tty *tty) { 1086c0: 55 push %ebp 1086c1: 89 e5 mov %esp,%ebp 1086c3: 56 push %esi 1086c4: 53 push %ebx 1086c5: 83 ec 10 sub $0x10,%esp 1086c8: 89 d3 mov %edx,%ebx 1086ca: 88 45 f4 mov %al,-0xc(%ebp) int i; if (tty->termios.c_oflag & OPOST) { 1086cd: 8b 52 34 mov 0x34(%edx),%edx 1086d0: f6 c2 01 test $0x1,%dl 1086d3: 74 17 je 1086ec <== NEVER TAKEN switch (c) { 1086d5: 3c 09 cmp $0x9,%al 1086d7: 74 53 je 10872c 1086d9: 77 29 ja 108704 <== ALWAYS TAKEN 1086db: 3c 08 cmp $0x8,%al <== NOT EXECUTED 1086dd: 75 2d jne 10870c <== NOT EXECUTED } tty->column += i; break; case '\b': if (tty->column > 0) 1086df: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 1086e2: 85 c0 test %eax,%eax <== NOT EXECUTED 1086e4: 7e 06 jle 1086ec <== NOT EXECUTED tty->column--; 1086e6: 48 dec %eax <== NOT EXECUTED 1086e7: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 1086ea: 66 90 xchg %ax,%ax <== NOT EXECUTED if (!iscntrl(c)) tty->column++; break; } } rtems_termios_puts (&c, 1, tty); 1086ec: 56 push %esi 1086ed: 53 push %ebx 1086ee: 6a 01 push $0x1 1086f0: 8d 45 f4 lea -0xc(%ebp),%eax 1086f3: 50 push %eax 1086f4: e8 97 fe ff ff call 108590 1086f9: 83 c4 10 add $0x10,%esp } 1086fc: 8d 65 f8 lea -0x8(%ebp),%esp 1086ff: 5b pop %ebx 108700: 5e pop %esi 108701: c9 leave 108702: c3 ret 108703: 90 nop oproc (unsigned char c, struct rtems_termios_tty *tty) { int i; if (tty->termios.c_oflag & OPOST) { switch (c) { 108704: 3c 0a cmp $0xa,%al 108706: 74 50 je 108758 108708: 3c 0d cmp $0xd,%al 10870a: 74 7c je 108788 <== NEVER TAKEN if (tty->column > 0) tty->column--; break; default: if (tty->termios.c_oflag & OLCUC) 10870c: 83 e2 02 and $0x2,%edx 10870f: 0f 85 a3 00 00 00 jne 1087b8 <== NEVER TAKEN 108715: 8b 15 14 c5 11 00 mov 0x11c514,%edx c = toupper(c); if (!iscntrl(c)) 10871b: 0f b6 45 f4 movzbl -0xc(%ebp),%eax 10871f: f6 04 02 20 testb $0x20,(%edx,%eax,1) 108723: 75 c7 jne 1086ec <== NEVER TAKEN tty->column++; 108725: ff 43 28 incl 0x28(%ebx) 108728: eb c2 jmp 1086ec 10872a: 66 90 xchg %ax,%ax } tty->column = 0; break; case '\t': i = 8 - (tty->column & 7); 10872c: 8b 73 28 mov 0x28(%ebx),%esi 10872f: 89 f0 mov %esi,%eax 108731: 83 e0 07 and $0x7,%eax 108734: b9 08 00 00 00 mov $0x8,%ecx 108739: 29 c1 sub %eax,%ecx if ((tty->termios.c_oflag & TABDLY) == XTABS) { 10873b: 81 e2 00 18 00 00 and $0x1800,%edx 108741: 81 fa 00 18 00 00 cmp $0x1800,%edx 108747: 0f 84 87 00 00 00 je 1087d4 <== ALWAYS TAKEN tty->column += i; rtems_termios_puts ( " ", i, tty); return; } tty->column += i; 10874d: 8d 04 31 lea (%ecx,%esi,1),%eax <== NOT EXECUTED 108750: 89 43 28 mov %eax,0x28(%ebx) <== NOT EXECUTED 108753: eb 97 jmp 1086ec <== NOT EXECUTED 108755: 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) 108758: f6 c2 20 test $0x20,%dl 10875b: 74 07 je 108764 <== ALWAYS TAKEN tty->column = 0; 10875d: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED if (tty->termios.c_oflag & ONLCR) { 108764: 83 e2 04 and $0x4,%edx 108767: 74 83 je 1086ec <== NEVER TAKEN rtems_termios_puts ("\r", 1, tty); 108769: 50 push %eax 10876a: 53 push %ebx 10876b: 6a 01 push $0x1 10876d: 68 b8 85 11 00 push $0x1185b8 108772: e8 19 fe ff ff call 108590 tty->column = 0; 108777: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) 10877e: 83 c4 10 add $0x10,%esp 108781: e9 66 ff ff ff jmp 1086ec 108786: 66 90 xchg %ax,%ax } break; case '\r': if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0)) 108788: f6 c2 10 test $0x10,%dl <== NOT EXECUTED 10878b: 74 0b je 108798 <== NOT EXECUTED 10878d: 8b 43 28 mov 0x28(%ebx),%eax <== NOT EXECUTED 108790: 85 c0 test %eax,%eax <== NOT EXECUTED 108792: 0f 84 64 ff ff ff je 1086fc <== NOT EXECUTED return; if (tty->termios.c_oflag & OCRNL) { 108798: f6 c2 08 test $0x8,%dl <== NOT EXECUTED 10879b: 74 0d je 1087aa <== NOT EXECUTED c = '\n'; 10879d: c6 45 f4 0a movb $0xa,-0xc(%ebp) <== NOT EXECUTED if (tty->termios.c_oflag & ONLRET) 1087a1: 83 e2 20 and $0x20,%edx <== NOT EXECUTED 1087a4: 0f 84 42 ff ff ff je 1086ec <== NOT EXECUTED tty->column = 0; break; } tty->column = 0; 1087aa: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx) <== NOT EXECUTED 1087b1: e9 36 ff ff ff jmp 1086ec <== NOT EXECUTED 1087b6: 66 90 xchg %ax,%ax <== NOT EXECUTED tty->column--; break; default: if (tty->termios.c_oflag & OLCUC) c = toupper(c); 1087b8: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 1087bb: 8b 15 14 c5 11 00 mov 0x11c514,%edx <== NOT EXECUTED 1087c1: f6 04 02 02 testb $0x2,(%edx,%eax,1) <== NOT EXECUTED 1087c5: 74 03 je 1087ca <== NOT EXECUTED 1087c7: 83 e8 20 sub $0x20,%eax <== NOT EXECUTED 1087ca: 88 45 f4 mov %al,-0xc(%ebp) <== NOT EXECUTED 1087cd: e9 49 ff ff ff jmp 10871b <== NOT EXECUTED 1087d2: 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; 1087d4: 8d 04 31 lea (%ecx,%esi,1),%eax 1087d7: 89 43 28 mov %eax,0x28(%ebx) rtems_termios_puts ( " ", i, tty); 1087da: 50 push %eax 1087db: 53 push %ebx 1087dc: 51 push %ecx 1087dd: 68 ba 85 11 00 push $0x1185ba 1087e2: e8 a9 fd ff ff call 108590 1087e7: 83 c4 10 add $0x10,%esp 1087ea: e9 0d ff ff ff jmp 1086fc =============================================================================== 00109080 : int posix_memalign( void **pointer, size_t alignment, size_t size ) { 109080: 55 push %ebp 109081: 89 e5 mov %esp,%ebp 109083: 53 push %ebx 109084: 8b 55 0c mov 0xc(%ebp),%edx /* * Update call statistics */ MSBUMP(memalign_calls, 1); 109087: ff 05 08 3c 12 00 incl 0x123c08 if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *))) 10908d: 8d 42 ff lea -0x1(%edx),%eax 109090: 85 d0 test %edx,%eax 109092: 75 05 jne 109099 <== NEVER TAKEN 109094: 83 fa 03 cmp $0x3,%edx 109097: 77 0b ja 1090a4 /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); } 109099: b8 16 00 00 00 mov $0x16,%eax 10909e: 5b pop %ebx 10909f: c9 leave 1090a0: c3 ret 1090a1: 8d 76 00 lea 0x0(%esi),%esi 1090a4: 5b pop %ebx 1090a5: c9 leave /* * rtems_memalign does all of the error checking work EXCEPT * for adding restrictionso on the alignment. */ return rtems_memalign( pointer, alignment, size ); 1090a6: e9 35 04 00 00 jmp 1094e0 =============================================================================== 00116794 : ssize_t read( int fd, void *buffer, size_t count ) { 116794: 55 push %ebp <== NOT EXECUTED 116795: 89 e5 mov %esp,%ebp <== NOT EXECUTED 116797: 56 push %esi <== NOT EXECUTED 116798: 53 push %ebx <== NOT EXECUTED 116799: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 11679c: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED 11679f: 8b 4d 10 mov 0x10(%ebp),%ecx <== NOT EXECUTED ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 1167a2: 3b 15 40 a0 11 00 cmp 0x11a040,%edx <== NOT EXECUTED 1167a8: 73 56 jae 116800 <== NOT EXECUTED iop = rtems_libio_iop( fd ); 1167aa: 8d 04 52 lea (%edx,%edx,2),%eax <== NOT EXECUTED 1167ad: 8d 04 82 lea (%edx,%eax,4),%eax <== NOT EXECUTED 1167b0: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx <== NOT EXECUTED 1167b7: 03 1d d0 e4 11 00 add 0x11e4d0,%ebx <== NOT EXECUTED rtems_libio_check_is_open( iop ); 1167bd: 8b 43 0c mov 0xc(%ebx),%eax <== NOT EXECUTED 1167c0: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 1167c3: 74 3b je 116800 <== NOT EXECUTED rtems_libio_check_buffer( buffer ); 1167c5: 85 f6 test %esi,%esi <== NOT EXECUTED 1167c7: 74 5b je 116824 <== NOT EXECUTED rtems_libio_check_count( count ); 1167c9: 85 c9 test %ecx,%ecx <== NOT EXECUTED 1167cb: 74 27 je 1167f4 <== NOT EXECUTED rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF ); 1167cd: a8 02 test $0x2,%al <== NOT EXECUTED 1167cf: 74 2f je 116800 <== NOT EXECUTED /* * Now process the read(). */ if ( !iop->handlers->read_h ) 1167d1: 8b 43 30 mov 0x30(%ebx),%eax <== NOT EXECUTED 1167d4: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED 1167d7: 85 c0 test %eax,%eax <== NOT EXECUTED 1167d9: 74 37 je 116812 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); rc = (*iop->handlers->read_h)( iop, buffer, count ); 1167db: 52 push %edx <== NOT EXECUTED 1167dc: 51 push %ecx <== NOT EXECUTED 1167dd: 56 push %esi <== NOT EXECUTED 1167de: 53 push %ebx <== NOT EXECUTED 1167df: ff d0 call *%eax <== NOT EXECUTED if ( rc > 0 ) 1167e1: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1167e4: 85 c0 test %eax,%eax <== NOT EXECUTED 1167e6: 7e 03 jle 1167eb <== NOT EXECUTED iop->offset += rc; 1167e8: 01 43 08 add %eax,0x8(%ebx) <== NOT EXECUTED return rc; } 1167eb: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1167ee: 5b pop %ebx <== NOT EXECUTED 1167ef: 5e pop %esi <== NOT EXECUTED 1167f0: c9 leave <== NOT EXECUTED 1167f1: c3 ret <== NOT EXECUTED 1167f2: 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 ); 1167f4: 31 c0 xor %eax,%eax <== NOT EXECUTED if ( rc > 0 ) iop->offset += rc; return rc; } 1167f6: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1167f9: 5b pop %ebx <== NOT EXECUTED 1167fa: 5e pop %esi <== NOT EXECUTED 1167fb: c9 leave <== NOT EXECUTED 1167fc: c3 ret <== NOT EXECUTED 1167fd: 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 ); rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF ); 116800: e8 1b 9a ff ff call 110220 <__errno> <== NOT EXECUTED 116805: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 11680b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 116810: eb d9 jmp 1167eb <== NOT EXECUTED /* * Now process the read(). */ if ( !iop->handlers->read_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 116812: e8 09 9a ff ff call 110220 <__errno> <== NOT EXECUTED 116817: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 11681d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 116822: eb c7 jmp 1167eb <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_buffer( buffer ); 116824: e8 f7 99 ff ff call 110220 <__errno> <== NOT EXECUTED 116829: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 11682f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 116834: eb b5 jmp 1167eb <== NOT EXECUTED =============================================================================== 001168b8 : { size_t old_size; char *new_area; size_t resize; MSBUMP(realloc_calls, 1); 1168b8: 55 push %ebp 1168b9: 89 e5 mov %esp,%ebp 1168bb: 57 push %edi 1168bc: 56 push %esi 1168bd: 53 push %ebx 1168be: 83 ec 1c sub $0x1c,%esp 1168c1: 8b 5d 08 mov 0x8(%ebp),%ebx 1168c4: 8b 75 0c mov 0xc(%ebp),%esi 1168c7: ff 05 70 e5 11 00 incl 0x11e570 /* * Do not attempt to allocate memory if in a critical section or ISR. */ if (_System_state_Is_up(_System_state_Get())) { 1168cd: 83 3d 24 e8 11 00 03 cmpl $0x3,0x11e824 1168d4: 74 6e je 116944 <== ALWAYS TAKEN } /* * Continue with realloc(). */ if ( !ptr ) 1168d6: 85 db test %ebx,%ebx 1168d8: 74 3a je 116914 <== NEVER TAKEN return malloc( size ); if ( !size ) { 1168da: 85 f6 test %esi,%esi 1168dc: 74 46 je 116924 <== NEVER TAKEN free( ptr ); return (void *) 0; } if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) { 1168de: 52 push %edx 1168df: 8d 45 f0 lea -0x10(%ebp),%eax 1168e2: 50 push %eax 1168e3: 53 push %ebx 1168e4: 68 00 e5 11 00 push $0x11e500 1168e9: e8 5a 01 00 00 call 116a48 <_Protected_heap_Get_block_size> 1168ee: 83 c4 10 add $0x10,%esp 1168f1: 84 c0 test %al,%al 1168f3: 74 3f je 116934 #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 ) ) { 1168f5: 50 push %eax 1168f6: 56 push %esi 1168f7: 53 push %ebx 1168f8: 68 00 e5 11 00 push $0x11e500 1168fd: e8 7e 01 00 00 call 116a80 <_Protected_heap_Resize_block> 116902: 83 c4 10 add $0x10,%esp 116905: 84 c0 test %al,%al 116907: 74 5b je 116964 memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; } 116909: 89 d8 mov %ebx,%eax 11690b: 8d 65 f4 lea -0xc(%ebp),%esp 11690e: 5b pop %ebx 11690f: 5e pop %esi 116910: 5f pop %edi 116911: c9 leave 116912: c3 ret 116913: 90 nop /* * Continue with realloc(). */ if ( !ptr ) return malloc( size ); 116914: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116917: 56 push %esi <== NOT EXECUTED 116918: e8 bb 09 ff ff call 1072d8 <== NOT EXECUTED 11691d: 89 c3 mov %eax,%ebx <== NOT EXECUTED 11691f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116922: eb e5 jmp 116909 <== NOT EXECUTED if ( !size ) { free( ptr ); 116924: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 116927: 53 push %ebx <== NOT EXECUTED 116928: e8 93 07 ff ff call 1070c0 <== NOT EXECUTED 11692d: 31 db xor %ebx,%ebx <== NOT EXECUTED 11692f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 116932: eb d5 jmp 116909 <== NOT EXECUTED return (void *) 0; } if ( !_Protected_heap_Get_block_size(&RTEMS_Malloc_Heap, ptr, &old_size) ) { errno = EINVAL; 116934: e8 e7 98 ff ff call 110220 <__errno> 116939: c7 00 16 00 00 00 movl $0x16,(%eax) 11693f: 31 db xor %ebx,%ebx 116941: eb c6 jmp 116909 116943: 90 nop /* * 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) 116944: a1 58 e6 11 00 mov 0x11e658,%eax 116949: 85 c0 test %eax,%eax 11694b: 74 04 je 116951 <== ALWAYS TAKEN } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; 11694d: 31 db xor %ebx,%ebx 11694f: eb b8 jmp 116909 <== NOT EXECUTED if (_System_state_Is_up(_System_state_Get())) { if (_Thread_Dispatch_disable_level > 0) return (void *) 0; if (_ISR_Nest_level > 0) 116951: a1 f8 e6 11 00 mov 0x11e6f8,%eax 116956: 85 c0 test %eax,%eax 116958: 0f 84 78 ff ff ff je 1168d6 <== ALWAYS TAKEN } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); free( ptr ); return new_area; 11695e: 31 db xor %ebx,%ebx 116960: eb a7 jmp 116909 <== NOT EXECUTED 116962: 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 ); 116964: 83 ec 0c sub $0xc,%esp 116967: 56 push %esi 116968: e8 6b 09 ff ff call 1072d8 11696d: 89 45 dc mov %eax,-0x24(%ebp) MSBUMP(malloc_calls, -1); /* subtract off the malloc */ 116970: ff 0d 64 e5 11 00 decl 0x11e564 if ( !new_area ) { 116976: 83 c4 10 add $0x10,%esp 116979: 85 c0 test %eax,%eax 11697b: 74 d0 je 11694d <== NEVER TAKEN return (void *) 0; } memcpy( new_area, ptr, (size < old_size) ? size : old_size ); 11697d: 8b 45 f0 mov -0x10(%ebp),%eax 116980: 89 f1 mov %esi,%ecx 116982: 39 c6 cmp %eax,%esi 116984: 76 02 jbe 116988 <== NEVER TAKEN 116986: 89 c1 mov %eax,%ecx 116988: 8b 7d dc mov -0x24(%ebp),%edi 11698b: 89 de mov %ebx,%esi 11698d: f3 a4 rep movsb %ds:(%esi),%es:(%edi) free( ptr ); 11698f: 83 ec 0c sub $0xc,%esp 116992: 53 push %ebx 116993: e8 28 07 ff ff call 1070c0 116998: 8b 5d dc mov -0x24(%ebp),%ebx 11699b: 83 c4 10 add $0x10,%esp 11699e: e9 66 ff ff ff jmp 116909 =============================================================================== 0010fca8 : uint32_t rtems_assoc_local_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10fca8: 55 push %ebp 10fca9: 89 e5 mov %esp,%ebp 10fcab: 83 ec 10 sub $0x10,%esp const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_remote(ap, remote_value); 10fcae: ff 75 0c pushl 0xc(%ebp) 10fcb1: ff 75 08 pushl 0x8(%ebp) 10fcb4: e8 0f 00 00 00 call 10fcc8 if (nap) 10fcb9: 83 c4 10 add $0x10,%esp 10fcbc: 85 c0 test %eax,%eax 10fcbe: 74 03 je 10fcc3 <== NEVER TAKEN return nap->local_value; 10fcc0: 8b 40 04 mov 0x4(%eax),%eax return 0; } 10fcc3: c9 leave 10fcc4: c3 ret =============================================================================== 0010fc64 : uint32_t rtems_assoc_local_by_remote_bitfield( const rtems_assoc_t *ap, uint32_t remote_value ) { 10fc64: 55 push %ebp 10fc65: 89 e5 mov %esp,%ebp 10fc67: 57 push %edi 10fc68: 56 push %esi 10fc69: 53 push %ebx 10fc6a: 83 ec 0c sub $0xc,%esp 10fc6d: be 01 00 00 00 mov $0x1,%esi 10fc72: 31 ff xor %edi,%edi 10fc74: 31 db xor %ebx,%ebx 10fc76: eb 08 jmp 10fc80 uint32_t b; uint32_t local_value = 0; for (b = 1; b; b <<= 1) { 10fc78: d1 e6 shl %esi 10fc7a: 43 inc %ebx 10fc7b: 83 fb 20 cmp $0x20,%ebx 10fc7e: 74 1e je 10fc9e if (b & remote_value) 10fc80: 85 75 0c test %esi,0xc(%ebp) 10fc83: 74 f3 je 10fc78 <== ALWAYS TAKEN local_value |= rtems_assoc_local_by_remote(ap, b); 10fc85: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10fc88: 56 push %esi <== NOT EXECUTED 10fc89: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10fc8c: e8 17 00 00 00 call 10fca8 <== NOT EXECUTED 10fc91: 09 c7 or %eax,%edi <== NOT EXECUTED 10fc93: 83 c4 10 add $0x10,%esp <== NOT EXECUTED ) { uint32_t b; uint32_t local_value = 0; for (b = 1; b; b <<= 1) { 10fc96: d1 e6 shl %esi <== NOT EXECUTED 10fc98: 43 inc %ebx <== NOT EXECUTED 10fc99: 83 fb 20 cmp $0x20,%ebx <== NOT EXECUTED 10fc9c: 75 e2 jne 10fc80 <== NOT EXECUTED if (b & remote_value) local_value |= rtems_assoc_local_by_remote(ap, b); } return local_value; } 10fc9e: 89 f8 mov %edi,%eax 10fca0: 8d 65 f4 lea -0xc(%ebp),%esp 10fca3: 5b pop %ebx 10fca4: 5e pop %esi 10fca5: 5f pop %edi 10fca6: c9 leave 10fca7: c3 ret =============================================================================== 001114e0 : const char * rtems_assoc_name_bad( uint32_t bad_value ) { 1114e0: 55 push %ebp <== NOT EXECUTED 1114e1: 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; } 1114e3: b8 a0 07 12 00 mov $0x1207a0,%eax <== NOT EXECUTED 1114e8: c9 leave <== NOT EXECUTED 1114e9: c3 ret <== NOT EXECUTED =============================================================================== 0010fbf8 : const char *rtems_assoc_name_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 10fbf8: 55 push %ebp <== NOT EXECUTED 10fbf9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fbfb: 53 push %ebx <== NOT EXECUTED 10fbfc: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10fbff: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 10fc02: 53 push %ebx <== NOT EXECUTED 10fc03: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10fc06: e8 1d 00 00 00 call 10fc28 <== NOT EXECUTED if (nap) 10fc0b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fc0e: 85 c0 test %eax,%eax <== NOT EXECUTED 10fc10: 74 0a je 10fc1c <== NOT EXECUTED return nap->name; 10fc12: 8b 00 mov (%eax),%eax <== NOT EXECUTED return rtems_assoc_name_bad(local_value); } 10fc14: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10fc17: c9 leave <== NOT EXECUTED 10fc18: c3 ret <== NOT EXECUTED 10fc19: 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); 10fc1c: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } 10fc1f: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10fc22: 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); 10fc23: e9 b8 18 00 00 jmp 1114e0 <== NOT EXECUTED =============================================================================== 001101a0 : const rtems_assoc_t *rtems_assoc_ptr_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 1101a0: 55 push %ebp 1101a1: 89 e5 mov %esp,%ebp 1101a3: 57 push %edi 1101a4: 56 push %esi 1101a5: 53 push %ebx 1101a6: 83 ec 04 sub $0x4,%esp 1101a9: 8b 5d 08 mov 0x8(%ebp),%ebx const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 1101ac: 8b 33 mov (%ebx),%esi 1101ae: 85 f6 test %esi,%esi 1101b0: 74 4a je 1101fc <== NEVER TAKEN 1101b2: bf 2d 8d 11 00 mov $0x118d2d,%edi 1101b7: b9 0a 00 00 00 mov $0xa,%ecx 1101bc: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 1101be: 74 20 je 1101e0 <== NEVER TAKEN 1101c0: 31 d2 xor %edx,%edx 1101c2: eb 09 jmp 1101cd default_ap = ap++; for ( ; ap->name; ap++) 1101c4: 83 c3 0c add $0xc,%ebx 1101c7: 8b 0b mov (%ebx),%ecx 1101c9: 85 c9 test %ecx,%ecx 1101cb: 74 23 je 1101f0 if (ap->local_value == local_value) 1101cd: 8b 45 0c mov 0xc(%ebp),%eax 1101d0: 39 43 04 cmp %eax,0x4(%ebx) 1101d3: 75 ef jne 1101c4 return ap; return default_ap; } 1101d5: 89 d8 mov %ebx,%eax 1101d7: 5a pop %edx 1101d8: 5b pop %ebx 1101d9: 5e pop %esi 1101da: 5f pop %edi 1101db: c9 leave 1101dc: c3 ret 1101dd: 8d 76 00 lea 0x0(%esi),%esi ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 1101e0: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED for ( ; ap->name; ap++) 1101e3: 8b 73 0c mov 0xc(%ebx),%esi <== NOT EXECUTED 1101e6: 85 f6 test %esi,%esi <== NOT EXECUTED 1101e8: 74 eb je 1101d5 <== NOT EXECUTED 1101ea: 89 da mov %ebx,%edx <== NOT EXECUTED 1101ec: 89 c3 mov %eax,%ebx <== NOT EXECUTED 1101ee: eb dd jmp 1101cd <== NOT EXECUTED 1101f0: 89 d3 mov %edx,%ebx if (ap->local_value == local_value) return ap; return default_ap; } 1101f2: 89 d8 mov %ebx,%eax 1101f4: 5a pop %edx 1101f5: 5b pop %ebx 1101f6: 5e pop %esi 1101f7: 5f pop %edi 1101f8: c9 leave 1101f9: c3 ret 1101fa: 66 90 xchg %ax,%ax uint32_t local_value ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 1101fc: 31 db xor %ebx,%ebx for ( ; ap->name; ap++) if (ap->local_value == local_value) return ap; return default_ap; } 1101fe: 89 d8 mov %ebx,%eax <== NOT EXECUTED 110200: 5a pop %edx <== NOT EXECUTED 110201: 5b pop %ebx <== NOT EXECUTED 110202: 5e pop %esi <== NOT EXECUTED 110203: 5f pop %edi <== NOT EXECUTED 110204: c9 leave <== NOT EXECUTED 110205: c3 ret <== NOT EXECUTED =============================================================================== 0010fcc8 : const rtems_assoc_t *rtems_assoc_ptr_by_remote( const rtems_assoc_t *ap, uint32_t remote_value ) { 10fcc8: 55 push %ebp 10fcc9: 89 e5 mov %esp,%ebp 10fccb: 57 push %edi 10fccc: 56 push %esi 10fccd: 53 push %ebx 10fcce: 83 ec 04 sub $0x4,%esp 10fcd1: 8b 5d 08 mov 0x8(%ebp),%ebx const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 10fcd4: 8b 33 mov (%ebx),%esi 10fcd6: 85 f6 test %esi,%esi 10fcd8: 74 4a je 10fd24 <== NEVER TAKEN 10fcda: bf 2d 8d 11 00 mov $0x118d2d,%edi 10fcdf: b9 0a 00 00 00 mov $0xa,%ecx 10fce4: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 10fce6: 74 20 je 10fd08 <== NEVER TAKEN 10fce8: 31 d2 xor %edx,%edx 10fcea: eb 09 jmp 10fcf5 default_ap = ap++; for ( ; ap->name; ap++) 10fcec: 83 c3 0c add $0xc,%ebx 10fcef: 8b 0b mov (%ebx),%ecx 10fcf1: 85 c9 test %ecx,%ecx 10fcf3: 74 23 je 10fd18 <== NEVER TAKEN if (ap->remote_value == remote_value) 10fcf5: 8b 45 0c mov 0xc(%ebp),%eax 10fcf8: 39 43 08 cmp %eax,0x8(%ebx) 10fcfb: 75 ef jne 10fcec return ap; return default_ap; } 10fcfd: 89 d8 mov %ebx,%eax 10fcff: 5a pop %edx 10fd00: 5b pop %ebx 10fd01: 5e pop %esi 10fd02: 5f pop %edi 10fd03: c9 leave 10fd04: c3 ret 10fd05: 8d 76 00 lea 0x0(%esi),%esi ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) default_ap = ap++; 10fd08: 8d 43 0c lea 0xc(%ebx),%eax <== NOT EXECUTED for ( ; ap->name; ap++) 10fd0b: 8b 73 0c mov 0xc(%ebx),%esi <== NOT EXECUTED 10fd0e: 85 f6 test %esi,%esi <== NOT EXECUTED 10fd10: 74 eb je 10fcfd <== NOT EXECUTED 10fd12: 89 da mov %ebx,%edx <== NOT EXECUTED 10fd14: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10fd16: eb dd jmp 10fcf5 <== NOT EXECUTED 10fd18: 89 d3 mov %edx,%ebx <== NOT EXECUTED if (ap->remote_value == remote_value) return ap; return default_ap; } 10fd1a: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10fd1c: 5a pop %edx <== NOT EXECUTED 10fd1d: 5b pop %ebx <== NOT EXECUTED 10fd1e: 5e pop %esi <== NOT EXECUTED 10fd1f: 5f pop %edi <== NOT EXECUTED 10fd20: c9 leave <== NOT EXECUTED 10fd21: c3 ret <== NOT EXECUTED 10fd22: 66 90 xchg %ax,%ax <== NOT EXECUTED uint32_t remote_value ) { const rtems_assoc_t *default_ap = 0; if (rtems_assoc_is_default(ap)) 10fd24: 31 db xor %ebx,%ebx <== NOT EXECUTED for ( ; ap->name; ap++) if (ap->remote_value == remote_value) return ap; return default_ap; } 10fd26: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10fd28: 5a pop %edx <== NOT EXECUTED 10fd29: 5b pop %ebx <== NOT EXECUTED 10fd2a: 5e pop %esi <== NOT EXECUTED 10fd2b: 5f pop %edi <== NOT EXECUTED 10fd2c: c9 leave <== NOT EXECUTED 10fd2d: c3 ret <== NOT EXECUTED =============================================================================== 0010fd30 : uint32_t rtems_assoc_remote_by_local( const rtems_assoc_t *ap, uint32_t local_value ) { 10fd30: 55 push %ebp <== NOT EXECUTED 10fd31: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10fd33: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED const rtems_assoc_t *nap; nap = rtems_assoc_ptr_by_local(ap, local_value); 10fd36: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10fd39: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10fd3c: e8 5f 04 00 00 call 1101a0 <== NOT EXECUTED if (nap) 10fd41: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10fd44: 85 c0 test %eax,%eax <== NOT EXECUTED 10fd46: 74 03 je 10fd4b <== NOT EXECUTED return nap->remote_value; 10fd48: 8b 40 08 mov 0x8(%eax),%eax <== NOT EXECUTED return 0; } 10fd4b: c9 leave <== NOT EXECUTED 10fd4c: c3 ret <== NOT EXECUTED =============================================================================== 0010a78c : rtems_name name, rtems_attribute attribute_set, uint32_t maximum_waiters, rtems_id *id ) { 10a78c: 55 push %ebp 10a78d: 89 e5 mov %esp,%ebp 10a78f: 56 push %esi 10a790: 53 push %ebx 10a791: 83 ec 10 sub $0x10,%esp 10a794: 8b 75 08 mov 0x8(%ebp),%esi Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 10a797: 85 f6 test %esi,%esi 10a799: 0f 84 8d 00 00 00 je 10a82c <== NEVER TAKEN return RTEMS_INVALID_NAME; if ( !id ) 10a79f: 8b 55 14 mov 0x14(%ebp),%edx 10a7a2: 85 d2 test %edx,%edx 10a7a4: 0f 84 ba 00 00 00 je 10a864 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { 10a7aa: f6 45 0c 10 testb $0x10,0xc(%ebp) 10a7ae: 0f 84 84 00 00 00 je 10a838 the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; if ( maximum_waiters == 0 ) 10a7b4: 8b 45 10 mov 0x10(%ebp),%eax 10a7b7: 85 c0 test %eax,%eax 10a7b9: 0f 84 85 00 00 00 je 10a844 if ( !id ) return RTEMS_INVALID_ADDRESS; /* Initialize core barrier attributes */ if ( _Attributes_Is_barrier_automatic( attribute_set ) ) { the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE; 10a7bf: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp) if ( maximum_waiters == 0 ) return RTEMS_INVALID_NUMBER; } else the_attributes.discipline = CORE_BARRIER_MANUAL_RELEASE; the_attributes.maximum_count = maximum_waiters; 10a7c6: 8b 45 10 mov 0x10(%ebp),%eax 10a7c9: 89 45 f4 mov %eax,-0xc(%ebp) /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a7cc: a1 f8 16 12 00 mov 0x1216f8,%eax 10a7d1: 40 inc %eax 10a7d2: a3 f8 16 12 00 mov %eax,0x1216f8 #ifdef __cplusplus extern "C" { #endif /** 10a7d7: 83 ec 0c sub $0xc,%esp 10a7da: 68 00 16 12 00 push $0x121600 10a7df: e8 50 1d 00 00 call 10c534 <_Objects_Allocate> 10a7e4: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { 10a7e6: 83 c4 10 add $0x10,%esp 10a7e9: 85 c0 test %eax,%eax 10a7eb: 74 63 je 10a850 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_barrier->attribute_set = attribute_set; 10a7ed: 8b 45 0c mov 0xc(%ebp),%eax 10a7f0: 89 43 10 mov %eax,0x10(%ebx) _CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes ); 10a7f3: 83 ec 08 sub $0x8,%esp 10a7f6: 8d 45 f0 lea -0x10(%ebp),%eax 10a7f9: 50 push %eax 10a7fa: 8d 43 14 lea 0x14(%ebx),%eax 10a7fd: 50 push %eax 10a7fe: e8 5d 14 00 00 call 10bc60 <_CORE_barrier_Initialize> 10a803: 8b 4b 08 mov 0x8(%ebx),%ecx 10a806: 0f b7 d1 movzwl %cx,%edx 10a809: a1 1c 16 12 00 mov 0x12161c,%eax 10a80e: 89 1c 90 mov %ebx,(%eax,%edx,4) 10a811: 89 73 0c mov %esi,0xc(%ebx) &_Barrier_Information, &the_barrier->Object, (Objects_Name) name ); *id = the_barrier->Object.id; 10a814: 8b 45 14 mov 0x14(%ebp),%eax 10a817: 89 08 mov %ecx,(%eax) _Thread_Enable_dispatch(); 10a819: e8 4e 2a 00 00 call 10d26c <_Thread_Enable_dispatch> 10a81e: 31 c0 xor %eax,%eax 10a820: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; } 10a823: 8d 65 f8 lea -0x8(%ebp),%esp 10a826: 5b pop %ebx 10a827: 5e pop %esi 10a828: c9 leave 10a829: c3 ret 10a82a: 66 90 xchg %ax,%ax ) { Barrier_Control *the_barrier; CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) 10a82c: b8 03 00 00 00 mov $0x3,%eax <== NOT EXECUTED *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a831: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a834: 5b pop %ebx <== NOT EXECUTED 10a835: 5e pop %esi <== NOT EXECUTED 10a836: c9 leave <== NOT EXECUTED 10a837: 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; 10a838: c7 45 f0 01 00 00 00 movl $0x1,-0x10(%ebp) 10a83f: eb 85 jmp 10a7c6 10a841: 8d 76 00 lea 0x0(%esi),%esi 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 ) 10a844: b8 0a 00 00 00 mov $0xa,%eax *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a849: 8d 65 f8 lea -0x8(%ebp),%esp 10a84c: 5b pop %ebx 10a84d: 5e pop %esi 10a84e: c9 leave 10a84f: c3 ret _Thread_Disable_dispatch(); /* prevents deletion */ the_barrier = _Barrier_Allocate(); if ( !the_barrier ) { _Thread_Enable_dispatch(); 10a850: e8 17 2a 00 00 call 10d26c <_Thread_Enable_dispatch> 10a855: b8 05 00 00 00 mov $0x5,%eax *id = the_barrier->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a85a: 8d 65 f8 lea -0x8(%ebp),%esp 10a85d: 5b pop %ebx 10a85e: 5e pop %esi 10a85f: c9 leave 10a860: c3 ret 10a861: 8d 76 00 lea 0x0(%esi),%esi CORE_barrier_Attributes the_attributes; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 10a864: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a869: eb b8 jmp 10a823 <== NOT EXECUTED =============================================================================== 0010a8f8 : rtems_status_code rtems_barrier_release( rtems_id id, uint32_t *released ) { 10a8f8: 55 push %ebp 10a8f9: 89 e5 mov %esp,%ebp 10a8fb: 56 push %esi 10a8fc: 53 push %ebx 10a8fd: 83 ec 10 sub $0x10,%esp 10a900: 8b 5d 08 mov 0x8(%ebp),%ebx 10a903: 8b 75 0c mov 0xc(%ebp),%esi Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 10a906: 85 f6 test %esi,%esi 10a908: 74 46 je 10a950 <== NEVER TAKEN * 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 10a90a: 50 push %eax 10a90b: 8d 45 f4 lea -0xc(%ebp),%eax 10a90e: 50 push %eax 10a90f: 53 push %ebx 10a910: 68 00 16 12 00 push $0x121600 10a915: e8 0e 21 00 00 call 10ca28 <_Objects_Get> return RTEMS_INVALID_ADDRESS; the_barrier = _Barrier_Get( id, &location ); switch ( location ) { 10a91a: 83 c4 10 add $0x10,%esp 10a91d: 8b 4d f4 mov -0xc(%ebp),%ecx 10a920: 85 c9 test %ecx,%ecx 10a922: 74 0c je 10a930 10a924: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a929: 8d 65 f8 lea -0x8(%ebp),%esp 10a92c: 5b pop %ebx 10a92d: 5e pop %esi 10a92e: c9 leave 10a92f: c3 ret the_barrier = _Barrier_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *released = _CORE_barrier_Release( &the_barrier->Barrier, id, NULL ); 10a930: 52 push %edx 10a931: 6a 00 push $0x0 10a933: 53 push %ebx 10a934: 83 c0 14 add $0x14,%eax 10a937: 50 push %eax 10a938: e8 57 13 00 00 call 10bc94 <_CORE_barrier_Release> 10a93d: 89 06 mov %eax,(%esi) _Thread_Enable_dispatch(); 10a93f: e8 28 29 00 00 call 10d26c <_Thread_Enable_dispatch> 10a944: 31 c0 xor %eax,%eax 10a946: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a949: 8d 65 f8 lea -0x8(%ebp),%esp 10a94c: 5b pop %ebx 10a94d: 5e pop %esi 10a94e: c9 leave 10a94f: c3 ret ) { Barrier_Control *the_barrier; Objects_Locations location; if ( !released ) 10a950: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a955: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a958: 5b pop %ebx <== NOT EXECUTED 10a959: 5e pop %esi <== NOT EXECUTED 10a95a: c9 leave <== NOT EXECUTED 10a95b: c3 ret <== NOT EXECUTED =============================================================================== 00109b10 : rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { 109b10: 55 push %ebp 109b11: 89 e5 mov %esp,%ebp 109b13: 53 push %ebx 109b14: 83 ec 04 sub $0x4,%esp 109b17: 8b 45 08 mov 0x8(%ebp),%eax 109b1a: 8b 5d 0c mov 0xc(%ebp),%ebx if ( !time_buffer ) 109b1d: 85 db test %ebx,%ebx 109b1f: 74 5b je 109b7c <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; switch ( option ) { 109b21: 83 f8 04 cmp $0x4,%eax 109b24: 76 0a jbe 109b30 109b26: b8 0a 00 00 00 mov $0xa,%eax break; } return RTEMS_INVALID_NUMBER; } 109b2b: 5a pop %edx 109b2c: 5b pop %ebx 109b2d: c9 leave 109b2e: c3 ret 109b2f: 90 nop ) { if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; switch ( option ) { 109b30: ff 24 85 c8 85 11 00 jmp *0x1185c8(,%eax,4) 109b37: 90 nop *interval = rtems_clock_get_ticks_per_second(); return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_TIME_VALUE: return rtems_clock_get_tod_timeval( (struct timeval *)time_buffer ); 109b38: 89 5d 08 mov %ebx,0x8(%ebp) break; } return RTEMS_INVALID_NUMBER; } 109b3b: 59 pop %ecx 109b3c: 5b pop %ebx 109b3d: c9 leave *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 ); 109b3e: e9 3d 01 00 00 jmp 109c80 109b43: 90 nop return RTEMS_SUCCESSFUL; } case RTEMS_CLOCK_GET_TICKS_PER_SECOND: { rtems_interval *interval = (rtems_interval *)time_buffer; *interval = rtems_clock_get_ticks_per_second(); 109b44: e8 6b 00 00 00 call 109bb4 109b49: 89 03 mov %eax,(%ebx) 109b4b: 31 c0 xor %eax,%eax break; } return RTEMS_INVALID_NUMBER; } 109b4d: 5a pop %edx 109b4e: 5b pop %ebx 109b4f: c9 leave 109b50: c3 ret 109b51: 8d 76 00 lea 0x0(%esi),%esi 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(); 109b54: e8 6f 00 00 00 call 109bc8 109b59: 89 03 mov %eax,(%ebx) 109b5b: 31 c0 xor %eax,%eax break; } return RTEMS_INVALID_NUMBER; } 109b5d: 5a pop %edx 109b5e: 5b pop %ebx 109b5f: c9 leave 109b60: c3 ret 109b61: 8d 76 00 lea 0x0(%esi),%esi 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); 109b64: 89 5d 08 mov %ebx,0x8(%ebp) break; } return RTEMS_INVALID_NUMBER; } 109b67: 5b pop %ebx 109b68: 5b pop %ebx 109b69: c9 leave 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); 109b6a: e9 15 00 00 00 jmp 109b84 109b6f: 90 nop 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 ); 109b70: 89 5d 08 mov %ebx,0x8(%ebp) break; } return RTEMS_INVALID_NUMBER; } 109b73: 58 pop %eax 109b74: 5b pop %ebx 109b75: c9 leave 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 ); 109b76: e9 59 00 00 00 jmp 109bd4 109b7b: 90 nop rtems_status_code rtems_clock_get( rtems_clock_get_options option, void *time_buffer ) { if ( !time_buffer ) 109b7c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109b81: eb a8 jmp 109b2b <== NOT EXECUTED =============================================================================== 00109b84 : #include rtems_status_code rtems_clock_get_seconds_since_epoch( rtems_interval *the_interval ) { 109b84: 55 push %ebp 109b85: 89 e5 mov %esp,%ebp 109b87: 8b 55 08 mov 0x8(%ebp),%edx if ( !the_interval ) 109b8a: 85 d2 test %edx,%edx 109b8c: 74 1e je 109bac <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 109b8e: 80 3d 6c e6 11 00 00 cmpb $0x0,0x11e66c 109b95: 74 0d je 109ba4 return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch; 109b97: a1 ec e6 11 00 mov 0x11e6ec,%eax 109b9c: 89 02 mov %eax,(%edx) 109b9e: 31 c0 xor %eax,%eax return RTEMS_SUCCESSFUL; } 109ba0: c9 leave 109ba1: c3 ret 109ba2: 66 90 xchg %ax,%ax ) { if ( !the_interval ) return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 109ba4: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_NOT_DEFINED; *the_interval = _TOD_Seconds_since_epoch; return RTEMS_SUCCESSFUL; } 109ba9: c9 leave 109baa: c3 ret 109bab: 90 nop rtems_status_code rtems_clock_get_seconds_since_epoch( rtems_interval *the_interval ) { if ( !the_interval ) 109bac: 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; } 109bb1: c9 leave <== NOT EXECUTED 109bb2: c3 ret <== NOT EXECUTED =============================================================================== 00109bd4 : #include rtems_status_code rtems_clock_get_tod( rtems_time_of_day *time_buffer ) { 109bd4: 55 push %ebp 109bd5: 89 e5 mov %esp,%ebp 109bd7: 56 push %esi 109bd8: 53 push %ebx 109bd9: 83 ec 40 sub $0x40,%esp 109bdc: 8b 75 08 mov 0x8(%ebp),%esi rtems_time_of_day *tmbuf = time_buffer; struct tm time; struct timeval now; if ( !time_buffer ) 109bdf: 85 f6 test %esi,%esi 109be1: 0f 84 8d 00 00 00 je 109c74 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 109be7: 80 3d 6c e6 11 00 00 cmpb $0x0,0x11e66c 109bee: 75 0c jne 109bfc 109bf0: b8 0b 00 00 00 mov $0xb,%eax tmbuf->minute = time.tm_min; tmbuf->second = time.tm_sec; tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; return RTEMS_SUCCESSFUL; } 109bf5: 8d 65 f8 lea -0x8(%ebp),%esp 109bf8: 5b pop %ebx 109bf9: 5e pop %esi 109bfa: c9 leave 109bfb: c3 ret ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 109bfc: 9c pushf 109bfd: fa cli 109bfe: 5b pop %ebx * This routine grows @a the_heap memory area using the size bytes which 109bff: 83 ec 0c sub $0xc,%esp 109c02: 8d 45 e8 lea -0x18(%ebp),%eax 109c05: 50 push %eax 109c06: e8 31 16 00 00 call 10b23c <_TOD_Get> * begin at @a starting_address. 109c0b: 53 push %ebx 109c0c: 9d popf * * @param[in] the_heap is the heap to operate upon 109c0d: 8b 45 e8 mov -0x18(%ebp),%eax 109c10: 89 45 f0 mov %eax,-0x10(%ebp) * @param[in] starting_address is the starting address of the memory 109c13: b8 d3 4d 62 10 mov $0x10624dd3,%eax 109c18: f7 65 ec mull -0x14(%ebp) 109c1b: c1 ea 06 shr $0x6,%edx 109c1e: 89 55 f4 mov %edx,-0xc(%ebp) /* Obtain the current time */ _TOD_Get_timeval( &now ); /* Split it into a closer format */ gmtime_r( &now.tv_sec, &time ); 109c21: 58 pop %eax 109c22: 5a pop %edx 109c23: 8d 45 c4 lea -0x3c(%ebp),%eax 109c26: 50 push %eax 109c27: 8d 45 f0 lea -0x10(%ebp),%eax 109c2a: 50 push %eax 109c2b: e8 38 6d 00 00 call 110968 /* Now adjust it to the RTEMS format */ tmbuf->year = time.tm_year + 1900; 109c30: 8b 45 d8 mov -0x28(%ebp),%eax 109c33: 05 6c 07 00 00 add $0x76c,%eax 109c38: 89 06 mov %eax,(%esi) tmbuf->month = time.tm_mon + 1; 109c3a: 8b 45 d4 mov -0x2c(%ebp),%eax 109c3d: 40 inc %eax 109c3e: 89 46 04 mov %eax,0x4(%esi) tmbuf->day = time.tm_mday; 109c41: 8b 45 d0 mov -0x30(%ebp),%eax 109c44: 89 46 08 mov %eax,0x8(%esi) tmbuf->hour = time.tm_hour; 109c47: 8b 45 cc mov -0x34(%ebp),%eax 109c4a: 89 46 0c mov %eax,0xc(%esi) tmbuf->minute = time.tm_min; 109c4d: 8b 45 c8 mov -0x38(%ebp),%eax 109c50: 89 46 10 mov %eax,0x10(%esi) tmbuf->second = time.tm_sec; 109c53: 8b 45 c4 mov -0x3c(%ebp),%eax 109c56: 89 46 14 mov %eax,0x14(%esi) tmbuf->ticks = now.tv_usec / _TOD_Microseconds_per_tick; 109c59: 8b 45 f4 mov -0xc(%ebp),%eax 109c5c: 31 d2 xor %edx,%edx 109c5e: f7 35 20 e8 11 00 divl 0x11e820 109c64: 89 46 18 mov %eax,0x18(%esi) 109c67: 31 c0 xor %eax,%eax 109c69: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; } 109c6c: 8d 65 f8 lea -0x8(%ebp),%esp 109c6f: 5b pop %ebx 109c70: 5e pop %esi 109c71: c9 leave 109c72: c3 ret 109c73: 90 nop { rtems_time_of_day *tmbuf = time_buffer; struct tm time; struct timeval now; if ( !time_buffer ) 109c74: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109c79: e9 77 ff ff ff jmp 109bf5 <== NOT EXECUTED =============================================================================== 00109c80 : #include rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { 109c80: 55 push %ebp 109c81: 89 e5 mov %esp,%ebp 109c83: 56 push %esi 109c84: 53 push %ebx 109c85: 83 ec 10 sub $0x10,%esp 109c88: 8b 75 08 mov 0x8(%ebp),%esi if ( !time ) 109c8b: 85 f6 test %esi,%esi 109c8d: 74 45 je 109cd4 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( !_TOD_Is_set ) 109c8f: 80 3d 6c e6 11 00 00 cmpb $0x0,0x11e66c 109c96: 75 0c jne 109ca4 109c98: b8 0b 00 00 00 mov $0xb,%eax return RTEMS_NOT_DEFINED; _TOD_Get_timeval( time ); return RTEMS_SUCCESSFUL; } 109c9d: 8d 65 f8 lea -0x8(%ebp),%esp 109ca0: 5b pop %ebx 109ca1: 5e pop %esi 109ca2: c9 leave 109ca3: c3 ret ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** 109ca4: 9c pushf 109ca5: fa cli 109ca6: 5b pop %ebx * This routine grows @a the_heap memory area using the size bytes which 109ca7: 83 ec 0c sub $0xc,%esp 109caa: 8d 45 f0 lea -0x10(%ebp),%eax 109cad: 50 push %eax 109cae: e8 89 15 00 00 call 10b23c <_TOD_Get> * begin at @a starting_address. 109cb3: 53 push %ebx 109cb4: 9d popf * * @param[in] the_heap is the heap to operate upon 109cb5: 8b 45 f0 mov -0x10(%ebp),%eax 109cb8: 89 06 mov %eax,(%esi) * @param[in] starting_address is the starting address of the memory 109cba: b8 d3 4d 62 10 mov $0x10624dd3,%eax 109cbf: f7 65 f4 mull -0xc(%ebp) 109cc2: c1 ea 06 shr $0x6,%edx 109cc5: 89 56 04 mov %edx,0x4(%esi) 109cc8: 31 c0 xor %eax,%eax 109cca: 83 c4 10 add $0x10,%esp 109ccd: 8d 65 f8 lea -0x8(%ebp),%esp 109cd0: 5b pop %ebx 109cd1: 5e pop %esi 109cd2: c9 leave 109cd3: c3 ret rtems_status_code rtems_clock_get_tod_timeval( struct timeval *time ) { if ( !time ) 109cd4: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 109cd9: eb c2 jmp 109c9d <== NOT EXECUTED =============================================================================== 00109efc : * error code - if unsuccessful */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { 109efc: 55 push %ebp 109efd: 89 e5 mov %esp,%ebp 109eff: 83 ec 08 sub $0x8,%esp 109f02: 8b 45 08 mov 0x8(%ebp),%eax if ( !uptime ) 109f05: 85 c0 test %eax,%eax 109f07: 74 13 je 109f1c <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime( uptime ); 109f09: 83 ec 0c sub $0xc,%esp 109f0c: 50 push %eax 109f0d: e8 fe 16 00 00 call 10b610 <_TOD_Get_uptime> 109f12: 31 c0 xor %eax,%eax 109f14: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; } 109f17: c9 leave 109f18: c3 ret 109f19: 8d 76 00 lea 0x0(%esi),%esi */ rtems_status_code rtems_clock_get_uptime( struct timespec *uptime ) { if ( !uptime ) 109f1c: b0 09 mov $0x9,%al <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _TOD_Get_uptime( uptime ); return RTEMS_SUCCESSFUL; } 109f1e: c9 leave <== NOT EXECUTED 109f1f: c3 ret <== NOT EXECUTED =============================================================================== 0010aba0 : */ rtems_status_code rtems_clock_set( rtems_time_of_day *time_buffer ) { 10aba0: 55 push %ebp 10aba1: 89 e5 mov %esp,%ebp 10aba3: 53 push %ebx 10aba4: 83 ec 14 sub $0x14,%esp 10aba7: 8b 5d 08 mov 0x8(%ebp),%ebx struct timespec newtime; if ( !time_buffer ) 10abaa: 85 db test %ebx,%ebx 10abac: 74 66 je 10ac14 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { 10abae: 83 ec 0c sub $0xc,%esp 10abb1: 53 push %ebx 10abb2: e8 3d 01 00 00 call 10acf4 <_TOD_Validate> 10abb7: 83 c4 10 add $0x10,%esp 10abba: 84 c0 test %al,%al 10abbc: 75 0a jne 10abc8 10abbe: b8 14 00 00 00 mov $0x14,%eax _TOD_Set( &newtime ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 10abc3: 8b 5d fc mov -0x4(%ebp),%ebx 10abc6: c9 leave 10abc7: c3 ret if ( !time_buffer ) return RTEMS_INVALID_ADDRESS; if ( _TOD_Validate( time_buffer ) ) { newtime.tv_sec = _TOD_To_seconds( time_buffer ); 10abc8: 83 ec 0c sub $0xc,%esp 10abcb: 53 push %ebx 10abcc: e8 93 00 00 00 call 10ac64 <_TOD_To_seconds> 10abd1: 89 45 f4 mov %eax,-0xc(%ebp) newtime.tv_nsec = time_buffer->ticks * 10abd4: 8b 43 18 mov 0x18(%ebx),%eax 10abd7: 0f af 05 40 a8 12 00 imul 0x12a840,%eax 10abde: 8d 04 80 lea (%eax,%eax,4),%eax 10abe1: 8d 04 80 lea (%eax,%eax,4),%eax 10abe4: 8d 04 80 lea (%eax,%eax,4),%eax 10abe7: c1 e0 03 shl $0x3,%eax 10abea: 89 45 f8 mov %eax,-0x8(%ebp) /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10abed: a1 78 a6 12 00 mov 0x12a678,%eax 10abf2: 40 inc %eax 10abf3: a3 78 a6 12 00 mov %eax,0x12a678 (_TOD_Microseconds_per_tick * TOD_NANOSECONDS_PER_MICROSECOND); _Thread_Disable_dispatch(); _TOD_Set( &newtime ); 10abf8: 8d 45 f4 lea -0xc(%ebp),%eax 10abfb: 89 04 24 mov %eax,(%esp) 10abfe: e8 c9 19 00 00 call 10c5cc <_TOD_Set> _Thread_Enable_dispatch(); 10ac03: e8 b0 2b 00 00 call 10d7b8 <_Thread_Enable_dispatch> 10ac08: 31 c0 xor %eax,%eax 10ac0a: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 10ac0d: 8b 5d fc mov -0x4(%ebp),%ebx 10ac10: c9 leave 10ac11: c3 ret 10ac12: 66 90 xchg %ax,%ax rtems_time_of_day *time_buffer ) { struct timespec newtime; if ( !time_buffer ) 10ac14: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED _TOD_Set( &newtime ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } return RTEMS_INVALID_CLOCK; } 10ac19: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10ac1c: c9 leave <== NOT EXECUTED 10ac1d: c3 ret <== NOT EXECUTED =============================================================================== 00109cdc : * error code - if unsuccessful */ rtems_status_code rtems_clock_set_nanoseconds_extension( rtems_nanoseconds_extension_routine routine ) { 109cdc: 55 push %ebp 109cdd: 89 e5 mov %esp,%ebp 109cdf: 8b 45 08 mov 0x8(%ebp),%eax if ( !routine ) 109ce2: 85 c0 test %eax,%eax 109ce4: 74 0a je 109cf0 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; _Watchdog_Nanoseconds_since_tick_handler = routine; 109ce6: a3 28 e8 11 00 mov %eax,0x11e828 109ceb: 31 c0 xor %eax,%eax return RTEMS_SUCCESSFUL; } 109ced: c9 leave 109cee: c3 ret 109cef: 90 nop */ rtems_status_code rtems_clock_set_nanoseconds_extension( rtems_nanoseconds_extension_routine routine ) { if ( !routine ) 109cf0: b0 09 mov $0x9,%al <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _Watchdog_Nanoseconds_since_tick_handler = routine; return RTEMS_SUCCESSFUL; } 109cf2: c9 leave <== NOT EXECUTED 109cf3: c3 ret <== NOT EXECUTED =============================================================================== 00109cf4 : * * NOTE: This routine only works for leap-years through 2099. */ rtems_status_code rtems_clock_tick( void ) { 109cf4: 55 push %ebp 109cf5: 89 e5 mov %esp,%ebp 109cf7: 83 ec 08 sub $0x8,%esp _TOD_Tickle_ticks(); 109cfa: e8 cd 15 00 00 call 10b2cc <_TOD_Tickle_ticks> * 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 109cff: 83 ec 0c sub $0xc,%esp 109d02: 68 3c e7 11 00 push $0x11e73c 109d07: e8 8c 36 00 00 call 10d398 <_Watchdog_Tickle> _Watchdog_Tickle_ticks(); _Thread_Tickle_timeslice(); 109d0c: e8 37 31 00 00 call 10ce48 <_Thread_Tickle_timeslice> 109d11: a0 2c e7 11 00 mov 0x11e72c,%al if ( _Thread_Is_context_switch_necessary() && 109d16: 83 c4 10 add $0x10,%esp 109d19: 84 c0 test %al,%al 109d1b: 74 09 je 109d26 109d1d: a1 58 e6 11 00 mov 0x11e658,%eax 109d22: 85 c0 test %eax,%eax 109d24: 74 06 je 109d2c _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); return RTEMS_SUCCESSFUL; } 109d26: 31 c0 xor %eax,%eax 109d28: c9 leave 109d29: c3 ret 109d2a: 66 90 xchg %ax,%ax _Thread_Tickle_timeslice(); if ( _Thread_Is_context_switch_necessary() && _Thread_Is_dispatching_enabled() ) _Thread_Dispatch(); 109d2c: e8 5f 24 00 00 call 10c190 <_Thread_Dispatch> return RTEMS_SUCCESSFUL; } 109d31: 31 c0 xor %eax,%eax 109d33: c9 leave 109d34: c3 ret =============================================================================== 001077a8 : void rtems_cpu_usage_report_with_plugin( void *context, rtems_printk_plugin_t print ) { 1077a8: 55 push %ebp 1077a9: 89 e5 mov %esp,%ebp 1077ab: 57 push %edi 1077ac: 56 push %esi 1077ad: 53 push %ebx 1077ae: 83 ec 4c sub $0x4c,%esp struct timespec uptime, total, ran; #else uint32_t total_units = 0; #endif if ( !print ) 1077b1: 8b 4d 0c mov 0xc(%ebp),%ecx 1077b4: 85 c9 test %ecx,%ecx 1077b6: 0f 84 4e 01 00 00 je 10790a <== NEVER TAKEN * 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 ); 1077bc: 83 ec 0c sub $0xc,%esp 1077bf: 8d 45 e4 lea -0x1c(%ebp),%eax 1077c2: 50 push %eax 1077c3: e8 74 4d 00 00 call 10c53c <_TOD_Get_uptime> _Timespec_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total ); 1077c8: 83 c4 0c add $0xc,%esp 1077cb: 8d 55 dc lea -0x24(%ebp),%edx 1077ce: 52 push %edx 1077cf: 8d 45 e4 lea -0x1c(%ebp),%eax 1077d2: 50 push %eax 1077d3: 68 6c a9 12 00 push $0x12a96c 1077d8: e8 c3 6e 00 00 call 10e6a0 <_Timespec_Subtract> } } } #endif (*print)( context, "CPU Usage by thread\n" 1077dd: 58 pop %eax 1077de: 5a pop %edx 1077df: 68 34 b1 11 00 push $0x11b134 1077e4: ff 75 08 pushl 0x8(%ebp) 1077e7: ff 55 0c call *0xc(%ebp) 1077ea: c7 45 b0 01 00 00 00 movl $0x1,-0x50(%ebp) 1077f1: 83 c4 10 add $0x10,%esp ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 1077f4: 8b 55 b0 mov -0x50(%ebp),%edx 1077f7: 8b 04 95 4c a6 12 00 mov 0x12a64c(,%edx,4),%eax 1077fe: 85 c0 test %eax,%eax 107800: 0f 84 da 00 00 00 je 1078e0 continue; information = _Objects_Information_table[ api_index ][ 1 ]; 107806: 8b 78 04 mov 0x4(%eax),%edi if ( information ) { 107809: 85 ff test %edi,%edi 10780b: 0f 84 cf 00 00 00 je 1078e0 <== NEVER TAKEN for ( i=1 ; i <= information->maximum ; i++ ) { 107811: 66 83 7f 10 00 cmpw $0x0,0x10(%edi) 107816: 0f 84 c4 00 00 00 je 1078e0 <== NEVER TAKEN 10781c: be 01 00 00 00 mov $0x1,%esi 107821: eb 44 jmp 107867 107823: 90 nop 107824: 8d 5d d4 lea -0x2c(%ebp),%ebx _Timespec_Subtract( &_Thread_Time_of_last_context_switch, &uptime, &used ); _Timespec_Add_to( &ran, &used ); }; _Timespec_Divide( &ran, &total, &ival, &fval ); 107827: 8d 55 ec lea -0x14(%ebp),%edx 10782a: 52 push %edx 10782b: 8d 45 f0 lea -0x10(%ebp),%eax 10782e: 50 push %eax 10782f: 8d 45 dc lea -0x24(%ebp),%eax 107832: 50 push %eax 107833: 53 push %ebx 107834: e8 9f 6d 00 00 call 10e5d8 <_Timespec_Divide> /* * Print the information */ (*print)( context, 107839: 58 pop %eax 10783a: 5a pop %edx 10783b: ff 75 ec pushl -0x14(%ebp) 10783e: ff 75 f0 pushl -0x10(%ebp) 107841: b8 d3 4d 62 10 mov $0x10624dd3,%eax 107846: f7 65 d8 mull -0x28(%ebp) 107849: c1 ea 06 shr $0x6,%edx 10784c: 52 push %edx 10784d: ff 75 d4 pushl -0x2c(%ebp) 107850: 68 c2 b1 11 00 push $0x11b1c2 107855: ff 75 08 pushl 0x8(%ebp) 107858: ff 55 0c call *0xc(%ebp) 10785b: 83 c4 20 add $0x20,%esp 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++ ) { 10785e: 46 inc %esi 10785f: 0f b7 47 10 movzwl 0x10(%edi),%eax 107863: 39 f0 cmp %esi,%eax 107865: 72 79 jb 1078e0 the_thread = (Thread_Control *)information->local_table[ i ]; 107867: 8b 47 1c mov 0x1c(%edi),%eax 10786a: 8b 1c b0 mov (%eax,%esi,4),%ebx if ( !the_thread ) 10786d: 85 db test %ebx,%ebx 10786f: 74 ed je 10785e <== NEVER TAKEN continue; rtems_object_get_name( the_thread->Object.id, sizeof(name), name ); 107871: 50 push %eax 107872: 8d 45 bf lea -0x41(%ebp),%eax 107875: 50 push %eax 107876: 6a 0d push $0xd 107878: ff 73 08 pushl 0x8(%ebx) 10787b: e8 20 39 00 00 call 10b1a0 (*print)( 107880: 8d 55 bf lea -0x41(%ebp),%edx 107883: 52 push %edx 107884: ff 73 08 pushl 0x8(%ebx) 107887: 68 af b1 11 00 push $0x11b1af 10788c: ff 75 08 pushl 0x8(%ebp) 10788f: ff 55 0c call *0xc(%ebp) #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; 107892: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx 107898: 8b 83 88 00 00 00 mov 0x88(%ebx),%eax 10789e: 89 45 d8 mov %eax,-0x28(%ebp) 1078a1: 89 55 d4 mov %edx,-0x2c(%ebp) if ( _Thread_Executing->Object.id == the_thread->Object.id ) { 1078a4: 83 c4 20 add $0x20,%esp 1078a7: a1 3c a7 12 00 mov 0x12a73c,%eax 1078ac: 8b 40 08 mov 0x8(%eax),%eax 1078af: 3b 43 08 cmp 0x8(%ebx),%eax 1078b2: 0f 85 6c ff ff ff jne 107824 struct timespec used; _Timespec_Subtract( 1078b8: 50 push %eax 1078b9: 8d 5d cc lea -0x34(%ebp),%ebx 1078bc: 53 push %ebx 1078bd: 8d 45 e4 lea -0x1c(%ebp),%eax 1078c0: 50 push %eax 1078c1: 68 44 a7 12 00 push $0x12a744 1078c6: e8 d5 6d 00 00 call 10e6a0 <_Timespec_Subtract> &_Thread_Time_of_last_context_switch, &uptime, &used ); _Timespec_Add_to( &ran, &used ); 1078cb: 59 pop %ecx 1078cc: 58 pop %eax 1078cd: 53 push %ebx 1078ce: 8d 5d d4 lea -0x2c(%ebp),%ebx 1078d1: 53 push %ebx 1078d2: e8 c9 6c 00 00 call 10e5a0 <_Timespec_Add_to> 1078d7: 83 c4 10 add $0x10,%esp 1078da: e9 48 ff ff ff jmp 107827 1078df: 90 nop #endif ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 1078e0: ff 45 b0 incl -0x50(%ebp) " ID NAME TICKS PERCENT\n" #endif ); for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 1078e3: 83 7d b0 05 cmpl $0x5,-0x50(%ebp) 1078e7: 0f 85 07 ff ff ff jne 1077f4 } } } #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS (*print)( context, "Time since last CPU Usage reset %" PRId32 1078ed: b8 d3 4d 62 10 mov $0x10624dd3,%eax 1078f2: f7 65 e0 mull -0x20(%ebp) 1078f5: c1 ea 06 shr $0x6,%edx 1078f8: 52 push %edx 1078f9: ff 75 dc pushl -0x24(%ebp) 1078fc: 68 7c b1 11 00 push $0x11b17c 107901: ff 75 08 pushl 0x8(%ebp) 107904: ff 55 0c call *0xc(%ebp) 107907: 83 c4 10 add $0x10,%esp "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 } 10790a: 8d 65 f4 lea -0xc(%ebp),%esp 10790d: 5b pop %ebx 10790e: 5e pop %esi 10790f: 5f pop %edi 107910: c9 leave 107911: c3 ret =============================================================================== 0010f934 : { 0, 0, 0 }, }; static int rtems_deviceio_errno(rtems_status_code code) { 10f934: 55 push %ebp <== NOT EXECUTED 10f935: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10f937: 53 push %ebx <== NOT EXECUTED 10f938: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED int rc; if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t) code))) 10f93b: 50 push %eax <== NOT EXECUTED 10f93c: 68 e0 8b 11 00 push $0x118be0 <== NOT EXECUTED 10f941: e8 ea 03 00 00 call 10fd30 <== NOT EXECUTED 10f946: 89 c3 mov %eax,%ebx <== NOT EXECUTED 10f948: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10f94b: 85 c0 test %eax,%eax <== NOT EXECUTED 10f94d: 74 07 je 10f956 <== NOT EXECUTED { errno = rc; 10f94f: e8 cc 08 00 00 call 110220 <__errno> <== NOT EXECUTED 10f954: 89 18 mov %ebx,(%eax) <== NOT EXECUTED return -1; } return -1; } 10f956: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 10f95b: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10f95e: c9 leave <== NOT EXECUTED 10f95f: c3 ret <== NOT EXECUTED =============================================================================== 00107cd4 : int rtems_error( int error_flag, const char *printf_format, ... ) { 107cd4: 55 push %ebp <== NOT EXECUTED 107cd5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107cd7: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107cda: 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); 107cdd: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 107ce0: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 107ce3: e8 2c fe ff ff call 107b14 <== NOT EXECUTED va_end(arglist); return chars_written; } 107ce8: c9 leave <== NOT EXECUTED 107ce9: c3 ret <== NOT EXECUTED =============================================================================== 00109d38 : rtems_event_set event_in, rtems_option option_set, rtems_interval ticks, rtems_event_set *event_out ) { 109d38: 55 push %ebp 109d39: 89 e5 mov %esp,%ebp 109d3b: 83 ec 08 sub $0x8,%esp 109d3e: 8b 4d 08 mov 0x8(%ebp),%ecx 109d41: 8b 55 14 mov 0x14(%ebp),%edx RTEMS_API_Control *api; if ( !event_out ) 109d44: 85 d2 test %edx,%edx 109d46: 74 44 je 109d8c <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; 109d48: a1 1c e7 11 00 mov 0x11e71c,%eax 109d4d: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax if ( _Event_sets_Is_empty( event_in ) ) { 109d53: 85 c9 test %ecx,%ecx 109d55: 75 09 jne 109d60 *event_out = api->pending_events; 109d57: 8b 00 mov (%eax),%eax 109d59: 89 02 mov %eax,(%edx) 109d5b: 31 c0 xor %eax,%eax _Thread_Disable_dispatch(); _Event_Seize( event_in, option_set, ticks, event_out ); _Thread_Enable_dispatch(); return( _Thread_Executing->Wait.return_code ); } 109d5d: c9 leave 109d5e: c3 ret 109d5f: 90 nop /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 109d60: a1 58 e6 11 00 mov 0x11e658,%eax 109d65: 40 inc %eax 109d66: a3 58 e6 11 00 mov %eax,0x11e658 *event_out = api->pending_events; return RTEMS_SUCCESSFUL; } _Thread_Disable_dispatch(); _Event_Seize( event_in, option_set, ticks, event_out ); 109d6b: 52 push %edx 109d6c: ff 75 10 pushl 0x10(%ebp) 109d6f: ff 75 0c pushl 0xc(%ebp) 109d72: 51 push %ecx 109d73: e8 1c 00 00 00 call 109d94 <_Event_Seize> _Thread_Enable_dispatch(); 109d78: e8 6f 25 00 00 call 10c2ec <_Thread_Enable_dispatch> return( _Thread_Executing->Wait.return_code ); 109d7d: a1 1c e7 11 00 mov 0x11e71c,%eax 109d82: 8b 40 34 mov 0x34(%eax),%eax 109d85: 83 c4 10 add $0x10,%esp } 109d88: c9 leave 109d89: c3 ret 109d8a: 66 90 xchg %ax,%ax rtems_event_set *event_out ) { RTEMS_API_Control *api; if ( !event_out ) 109d8c: 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 ); } 109d91: c9 leave <== NOT EXECUTED 109d92: c3 ret <== NOT EXECUTED =============================================================================== 0010bc7c : rtems_status_code rtems_extension_create( rtems_name name, rtems_extensions_table *extension_table, Objects_Id *id ) { 10bc7c: 55 push %ebp 10bc7d: 89 e5 mov %esp,%ebp 10bc7f: 57 push %edi 10bc80: 56 push %esi 10bc81: 53 push %ebx 10bc82: 83 ec 0c sub $0xc,%esp 10bc85: 8b 7d 08 mov 0x8(%ebp),%edi 10bc88: 8b 75 10 mov 0x10(%ebp),%esi Extension_Control *the_extension; if ( !id ) 10bc8b: 85 f6 test %esi,%esi 10bc8d: 74 75 je 10bd04 return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10bc8f: 85 ff test %edi,%edi 10bc91: 75 0d jne 10bca0 10bc93: b8 03 00 00 00 mov $0x3,%eax ); *id = the_extension->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10bc98: 8d 65 f4 lea -0xc(%ebp),%esp 10bc9b: 5b pop %ebx 10bc9c: 5e pop %esi 10bc9d: 5f pop %edi 10bc9e: c9 leave 10bc9f: c3 ret /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10bca0: a1 78 a6 12 00 mov 0x12a678,%eax 10bca5: 40 inc %eax 10bca6: a3 78 a6 12 00 mov %eax,0x12a678 * It is a simple wrapper for the help with the addition of the * allocation mutex being used for protection. */ /**@{*/ #ifdef __cplusplus 10bcab: 83 ec 0c sub $0xc,%esp 10bcae: 68 00 a9 12 00 push $0x12a900 10bcb3: e8 c8 0c 00 00 call 10c980 <_Objects_Allocate> 10bcb8: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { 10bcba: 83 c4 10 add $0x10,%esp 10bcbd: 85 c0 test %eax,%eax 10bcbf: 74 37 je 10bcf8 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } _User_extensions_Add_set( &the_extension->Extension, extension_table ); 10bcc1: 83 ec 08 sub $0x8,%esp 10bcc4: ff 75 0c pushl 0xc(%ebp) 10bcc7: 8d 40 10 lea 0x10(%eax),%eax 10bcca: 50 push %eax 10bccb: e8 0c 2a 00 00 call 10e6dc <_User_extensions_Add_set> 10bcd0: 8b 4b 08 mov 0x8(%ebx),%ecx 10bcd3: 0f b7 d1 movzwl %cx,%edx 10bcd6: a1 1c a9 12 00 mov 0x12a91c,%eax 10bcdb: 89 1c 90 mov %ebx,(%eax,%edx,4) 10bcde: 89 7b 0c mov %edi,0xc(%ebx) &_Extension_Information, &the_extension->Object, (Objects_Name) name ); *id = the_extension->Object.id; 10bce1: 89 0e mov %ecx,(%esi) _Thread_Enable_dispatch(); 10bce3: e8 d0 1a 00 00 call 10d7b8 <_Thread_Enable_dispatch> 10bce8: 31 c0 xor %eax,%eax 10bcea: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; } 10bced: 8d 65 f4 lea -0xc(%ebp),%esp 10bcf0: 5b pop %ebx 10bcf1: 5e pop %esi 10bcf2: 5f pop %edi 10bcf3: c9 leave 10bcf4: c3 ret 10bcf5: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* to prevent deletion */ the_extension = _Extension_Allocate(); if ( !the_extension ) { _Thread_Enable_dispatch(); 10bcf8: e8 bb 1a 00 00 call 10d7b8 <_Thread_Enable_dispatch> 10bcfd: b8 05 00 00 00 mov $0x5,%eax 10bd02: eb 94 jmp 10bc98 Objects_Id *id ) { Extension_Control *the_extension; if ( !id ) 10bd04: b8 09 00 00 00 mov $0x9,%eax 10bd09: eb 8d jmp 10bc98 =============================================================================== 0010c428 : */ rtems_status_code rtems_extension_delete( Objects_Id id ) { 10c428: 55 push %ebp 10c429: 89 e5 mov %esp,%ebp 10c42b: 53 push %ebx 10c42c: 83 ec 18 sub $0x18,%esp * * @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 10c42f: 8d 45 f8 lea -0x8(%ebp),%eax 10c432: 50 push %eax 10c433: ff 75 08 pushl 0x8(%ebp) 10c436: 68 20 3c 12 00 push $0x123c20 10c43b: e8 bc 10 00 00 call 10d4fc <_Objects_Get> 10c440: 89 c3 mov %eax,%ebx Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 10c442: 83 c4 10 add $0x10,%esp 10c445: 8b 45 f8 mov -0x8(%ebp),%eax 10c448: 85 c0 test %eax,%eax 10c44a: 75 38 jne 10c484 case OBJECTS_LOCAL: _User_extensions_Remove_set( &the_extension->Extension ); 10c44c: 83 ec 0c sub $0xc,%esp 10c44f: 8d 43 10 lea 0x10(%ebx),%eax 10c452: 50 push %eax 10c453: e8 fc 27 00 00 call 10ec54 <_User_extensions_Remove_set> _Objects_Close( &_Extension_Information, &the_extension->Object ); 10c458: 59 pop %ecx 10c459: 58 pop %eax 10c45a: 53 push %ebx 10c45b: 68 20 3c 12 00 push $0x123c20 10c460: e8 23 0c 00 00 call 10d088 <_Objects_Close> * @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 10c465: 58 pop %eax 10c466: 5a pop %edx 10c467: 53 push %ebx 10c468: 68 20 3c 12 00 push $0x123c20 10c46d: e8 56 0f 00 00 call 10d3c8 <_Objects_Free> _Extension_Free( the_extension ); _Thread_Enable_dispatch(); 10c472: e8 c9 18 00 00 call 10dd40 <_Thread_Enable_dispatch> 10c477: 31 c0 xor %eax,%eax 10c479: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c47c: 8b 5d fc mov -0x4(%ebp),%ebx 10c47f: c9 leave 10c480: c3 ret 10c481: 8d 76 00 lea 0x0(%esi),%esi { Extension_Control *the_extension; Objects_Locations location; the_extension = _Extension_Get( id, &location ); switch ( location ) { 10c484: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c489: 8b 5d fc mov -0x4(%ebp),%ebx 10c48c: c9 leave 10c48d: c3 ret =============================================================================== 00106ee4 : int rtems_filesystem_evaluate_parent( int flags, rtems_filesystem_location_info_t *pathloc ) { 106ee4: 55 push %ebp <== NOT EXECUTED 106ee5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106ee7: 57 push %edi <== NOT EXECUTED 106ee8: 56 push %esi <== NOT EXECUTED 106ee9: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 106eec: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED rtems_filesystem_location_info_t parent; int result; if ( !pathloc ) 106eef: 85 f6 test %esi,%esi <== NOT EXECUTED 106ef1: 74 76 je 106f69 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */ if ( !pathloc->ops->evalpath_h ) 106ef3: 8b 46 08 mov 0x8(%esi),%eax <== NOT EXECUTED 106ef6: 8b 08 mov (%eax),%ecx <== NOT EXECUTED 106ef8: 85 c9 test %ecx,%ecx <== NOT EXECUTED 106efa: 74 54 je 106f50 <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); parent = *pathloc; 106efc: 8d 7d e8 lea -0x18(%ebp),%edi <== NOT EXECUTED 106eff: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 106f04: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED result = (*pathloc->ops->evalpath_h)( "..", flags, &parent ); 106f06: 52 push %edx <== NOT EXECUTED 106f07: 8d 7d e8 lea -0x18(%ebp),%edi <== NOT EXECUTED 106f0a: 57 push %edi <== NOT EXECUTED 106f0b: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 106f0e: 68 93 84 11 00 push $0x118493 <== NOT EXECUTED 106f13: ff 10 call *(%eax) <== NOT EXECUTED 106f15: 89 c6 mov %eax,%esi <== NOT EXECUTED if (result != 0){ 106f17: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106f1a: 85 c0 test %eax,%eax <== NOT EXECUTED 106f1c: 75 22 jne 106f40 <== NOT EXECUTED return -1; } rtems_filesystem_freenode( &parent ); 106f1e: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 106f21: 85 c0 test %eax,%eax <== NOT EXECUTED 106f23: 74 10 je 106f35 <== NOT EXECUTED 106f25: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 106f28: 85 c0 test %eax,%eax <== NOT EXECUTED 106f2a: 74 09 je 106f35 <== NOT EXECUTED 106f2c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106f2f: 57 push %edi <== NOT EXECUTED 106f30: ff d0 call *%eax <== NOT EXECUTED 106f32: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return result; } 106f35: 89 f0 mov %esi,%eax <== NOT EXECUTED 106f37: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 106f3a: 5e pop %esi <== NOT EXECUTED 106f3b: 5f pop %edi <== NOT EXECUTED 106f3c: c9 leave <== NOT EXECUTED 106f3d: c3 ret <== NOT EXECUTED 106f3e: 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){ 106f40: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED return -1; } rtems_filesystem_freenode( &parent ); return result; } 106f45: 89 f0 mov %esi,%eax <== NOT EXECUTED 106f47: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 106f4a: 5e pop %esi <== NOT EXECUTED 106f4b: 5f pop %edi <== NOT EXECUTED 106f4c: c9 leave <== NOT EXECUTED 106f4d: c3 ret <== NOT EXECUTED 106f4e: 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 ); 106f50: e8 cb 92 00 00 call 110220 <__errno> <== NOT EXECUTED 106f55: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 106f5b: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED return -1; } rtems_filesystem_freenode( &parent ); return result; } 106f60: 89 f0 mov %esi,%eax <== NOT EXECUTED 106f62: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 106f65: 5e pop %esi <== NOT EXECUTED 106f66: 5f pop %edi <== NOT EXECUTED 106f67: c9 leave <== NOT EXECUTED 106f68: 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 */ 106f69: e8 b2 92 00 00 call 110220 <__errno> <== NOT EXECUTED 106f6e: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 106f74: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 106f79: eb ba jmp 106f35 <== NOT EXECUTED =============================================================================== 00106f7c : const char *pathname, int flags, rtems_filesystem_location_info_t *pathloc, int follow_link ) { 106f7c: 55 push %ebp 106f7d: 89 e5 mov %esp,%ebp 106f7f: 57 push %edi 106f80: 56 push %esi 106f81: 53 push %ebx 106f82: 83 ec 1c sub $0x1c,%esp 106f85: 8b 5d 08 mov 0x8(%ebp),%ebx 106f88: 8b 45 0c mov 0xc(%ebp),%eax 106f8b: 89 45 f0 mov %eax,-0x10(%ebp) 106f8e: 8b 55 10 mov 0x10(%ebp),%edx 106f91: 89 55 e0 mov %edx,-0x20(%ebp) 106f94: 8b 7d 14 mov 0x14(%ebp),%edi 106f97: 89 7d ec mov %edi,-0x14(%ebp) /* * Verify Input parameters. */ if ( !pathname ) 106f9a: 85 db test %ebx,%ebx 106f9c: 0f 84 08 01 00 00 je 1070aa <== NEVER TAKEN rtems_set_errno_and_return_minus_one( EFAULT ); if ( !pathloc ) 106fa2: 8b 7d e0 mov -0x20(%ebp),%edi 106fa5: 85 ff test %edi,%edi 106fa7: 0f 84 eb 00 00 00 je 107098 <== NEVER TAKEN /* * Evaluate the path using the optable evalpath. */ rtems_filesystem_get_start_loc( pathname, &i, pathloc ); 106fad: 8a 03 mov (%ebx),%al 106faf: 3c 2f cmp $0x2f,%al 106fb1: 74 1d je 106fd0 <== ALWAYS TAKEN 106fb3: 3c 5c cmp $0x5c,%al <== NOT EXECUTED 106fb5: 74 19 je 106fd0 <== NOT EXECUTED 106fb7: 84 c0 test %al,%al <== NOT EXECUTED 106fb9: 74 15 je 106fd0 <== NOT EXECUTED 106fbb: a1 b4 c4 11 00 mov 0x11c4b4,%eax <== NOT EXECUTED 106fc0: 8d 70 04 lea 0x4(%eax),%esi <== NOT EXECUTED 106fc3: b9 04 00 00 00 mov $0x4,%ecx <== NOT EXECUTED 106fc8: 8b 7d e0 mov -0x20(%ebp),%edi <== NOT EXECUTED 106fcb: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 106fcd: eb 15 jmp 106fe4 <== NOT EXECUTED 106fcf: 90 nop <== NOT EXECUTED 106fd0: a1 b4 c4 11 00 mov 0x11c4b4,%eax 106fd5: 8d 70 14 lea 0x14(%eax),%esi 106fd8: b9 04 00 00 00 mov $0x4,%ecx 106fdd: 8b 7d e0 mov -0x20(%ebp),%edi 106fe0: f3 a5 rep movsl %ds:(%esi),%es:(%edi) 106fe2: b1 01 mov $0x1,%cl if ( !pathloc->ops->evalpath_h ) 106fe4: 8b 55 e0 mov -0x20(%ebp),%edx 106fe7: 8b 42 08 mov 0x8(%edx),%eax 106fea: 8b 10 mov (%eax),%edx 106fec: 85 d2 test %edx,%edx 106fee: 0f 84 80 00 00 00 je 107074 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); result = (*pathloc->ops->evalpath_h)( &pathname[i], flags, pathloc ); 106ff4: 56 push %esi 106ff5: ff 75 e0 pushl -0x20(%ebp) 106ff8: ff 75 f0 pushl -0x10(%ebp) 106ffb: 8d 04 0b lea (%ebx,%ecx,1),%eax 106ffe: 50 push %eax 106fff: ff d2 call *%edx 107001: 89 c6 mov %eax,%esi /* * Get the Node type and determine if you need to follow the link or * not. */ if ( (result == 0) && follow_link ) { 107003: 83 c4 10 add $0x10,%esp 107006: 85 c0 test %eax,%eax 107008: 75 2a jne 107034 <== NEVER TAKEN 10700a: 8b 5d ec mov -0x14(%ebp),%ebx 10700d: 85 db test %ebx,%ebx 10700f: 74 23 je 107034 if ( !pathloc->ops->node_type_h ){ 107011: 8b 7d e0 mov -0x20(%ebp),%edi 107014: 8b 57 08 mov 0x8(%edi),%edx 107017: 8b 42 10 mov 0x10(%edx),%eax 10701a: 85 c0 test %eax,%eax 10701c: 74 68 je 107086 <== NEVER TAKEN rtems_filesystem_freenode( pathloc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } type = (*pathloc->ops->node_type_h)( pathloc ); 10701e: 83 ec 0c sub $0xc,%esp 107021: ff 75 e0 pushl -0x20(%ebp) 107024: ff d0 call *%eax if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) || 107026: 83 e8 03 sub $0x3,%eax 107029: 83 c4 10 add $0x10,%esp 10702c: 83 f8 01 cmp $0x1,%eax 10702f: 76 0f jbe 107040 <== NEVER TAKEN 107031: 8d 76 00 lea 0x0(%esi),%esi } } return result; } 107034: 89 f0 mov %esi,%eax 107036: 8d 65 f4 lea -0xc(%ebp),%esp 107039: 5b pop %ebx 10703a: 5e pop %esi 10703b: 5f pop %edi 10703c: c9 leave 10703d: c3 ret 10703e: 66 90 xchg %ax,%ax type = (*pathloc->ops->node_type_h)( pathloc ); if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) || ( type == RTEMS_FILESYSTEM_SYM_LINK ) ) { if ( !pathloc->ops->eval_link_h ){ 107040: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 107043: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 107046: 8b 48 34 mov 0x34(%eax),%ecx <== NOT EXECUTED 107049: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10704b: 74 15 je 107062 <== 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 ); 10704d: 8b 7d f0 mov -0x10(%ebp),%edi <== NOT EXECUTED 107050: 89 7d 0c mov %edi,0xc(%ebp) <== NOT EXECUTED 107053: 8b 45 e0 mov -0x20(%ebp),%eax <== NOT EXECUTED 107056: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED } } return result; } 107059: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10705c: 5b pop %ebx <== NOT EXECUTED 10705d: 5e pop %esi <== NOT EXECUTED 10705e: 5f pop %edi <== NOT EXECUTED 10705f: 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 ); 107060: 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 ); 107062: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 107065: 85 c0 test %eax,%eax <== NOT EXECUTED 107067: 74 0b je 107074 <== NOT EXECUTED 107069: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10706c: 52 push %edx <== NOT EXECUTED 10706d: ff d0 call *%eax <== NOT EXECUTED 10706f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107072: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 107074: e8 a7 91 00 00 call 110220 <__errno> <== NOT EXECUTED 107079: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 10707f: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 107084: eb ae jmp 107034 <== NOT EXECUTED */ if ( (result == 0) && follow_link ) { if ( !pathloc->ops->node_type_h ){ rtems_filesystem_freenode( pathloc ); 107086: 8b 42 1c mov 0x1c(%edx),%eax <== NOT EXECUTED 107089: 85 c0 test %eax,%eax <== NOT EXECUTED 10708b: 74 e7 je 107074 <== NOT EXECUTED 10708d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107090: 57 push %edi <== NOT EXECUTED 107091: ff d0 call *%eax <== NOT EXECUTED 107093: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107096: eb dc jmp 107074 <== 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 */ 107098: e8 83 91 00 00 call 110220 <__errno> <== NOT EXECUTED 10709d: c7 00 05 00 00 00 movl $0x5,(%eax) <== NOT EXECUTED 1070a3: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 1070a8: eb 8a jmp 107034 <== NOT EXECUTED /* * Verify Input parameters. */ if ( !pathname ) rtems_set_errno_and_return_minus_one( EFAULT ); 1070aa: e8 71 91 00 00 call 110220 <__errno> <== NOT EXECUTED 1070af: c7 00 0e 00 00 00 movl $0xe,(%eax) <== NOT EXECUTED 1070b5: be ff ff ff ff mov $0xffffffff,%esi <== NOT EXECUTED 1070ba: e9 75 ff ff ff jmp 107034 <== NOT EXECUTED =============================================================================== 0010e3c8 : * configuration is a single instantiation of the IMFS or miniIMFS with * a single "/dev" directory in it. */ void rtems_filesystem_initialize( void ) { 10e3c8: 55 push %ebp 10e3c9: 89 e5 mov %esp,%ebp 10e3cb: 57 push %edi 10e3cc: 56 push %esi 10e3cd: 53 push %ebx 10e3ce: 83 ec 2c sub $0x2c,%esp /* * Set the default umask to "022". */ rtems_filesystem_umask = 022; 10e3d1: a1 b4 c4 11 00 mov 0x11c4b4,%eax 10e3d6: c7 40 24 12 00 00 00 movl $0x12,0x24(%eax) init_fs_mount_table(); 10e3dd: e8 5a 05 00 00 call 10e93c /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) 10e3e2: a1 6c 6f 11 00 mov 0x116f6c,%eax 10e3e7: 85 c0 test %eax,%eax 10e3e9: 0f 84 a5 00 00 00 je 10e494 <== NEVER TAKEN rtems_fatal_error_occurred( 0xABCD0001 ); mt = &rtems_filesystem_mount_table[0]; 10e3ef: a1 48 a0 11 00 mov 0x11a048,%eax status = mount( 10e3f4: 83 ec 0c sub $0xc,%esp 10e3f7: ff 70 0c pushl 0xc(%eax) 10e3fa: ff 70 08 pushl 0x8(%eax) 10e3fd: ff 70 04 pushl 0x4(%eax) 10e400: ff 30 pushl (%eax) 10e402: 8d 45 f0 lea -0x10(%ebp),%eax 10e405: 50 push %eax 10e406: e8 59 05 00 00 call 10e964 &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point ); if ( status == -1 ) 10e40b: 83 c4 20 add $0x20,%esp 10e40e: 40 inc %eax 10e40f: 0f 84 8c 00 00 00 je 10e4a1 <== NEVER TAKEN rtems_fatal_error_occurred( 0xABCD0002 ); rtems_filesystem_link_counts = 0; 10e415: a1 b4 c4 11 00 mov 0x11c4b4,%eax 10e41a: 66 c7 40 28 00 00 movw $0x0,0x28(%eax) * set_private_env() - but then: that's * gonna hit performance. * * Till Straumann, 10/25/2002 */ rtems_filesystem_root = entry->mt_fs_root; 10e420: 8d 78 14 lea 0x14(%eax),%edi 10e423: 8b 45 f0 mov -0x10(%ebp),%eax 10e426: 8d 70 18 lea 0x18(%eax),%esi 10e429: b9 04 00 00 00 mov $0x4,%ecx 10e42e: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* Clone the root pathloc */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 10e430: 6a 00 push $0x0 10e432: 8d 5d e0 lea -0x20(%ebp),%ebx 10e435: 53 push %ebx 10e436: 6a 00 push $0x0 10e438: 68 b8 8a 11 00 push $0x118ab8 10e43d: e8 3a 8b ff ff call 106f7c rtems_filesystem_root = loc; 10e442: a1 b4 c4 11 00 mov 0x11c4b4,%eax 10e447: 8d 78 14 lea 0x14(%eax),%edi 10e44a: b9 04 00 00 00 mov $0x4,%ecx 10e44f: 89 de mov %ebx,%esi 10e451: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* One more clone for the current node */ rtems_filesystem_evaluate_path("/", 0, &loc, 0); 10e453: 6a 00 push $0x0 10e455: 53 push %ebx 10e456: 6a 00 push $0x0 10e458: 68 b8 8a 11 00 push $0x118ab8 10e45d: e8 1a 8b ff ff call 106f7c rtems_filesystem_current = loc; 10e462: a1 b4 c4 11 00 mov 0x11c4b4,%eax 10e467: 8d 78 04 lea 0x4(%eax),%edi 10e46a: b9 04 00 00 00 mov $0x4,%ecx 10e46f: 89 de mov %ebx,%esi 10e471: f3 a5 rep movsl %ds:(%esi),%es:(%edi) * * 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); 10e473: 83 c4 18 add $0x18,%esp 10e476: 68 ff 01 00 00 push $0x1ff 10e47b: 68 ba 8a 11 00 push $0x118aba 10e480: e8 9b 04 00 00 call 10e920 if ( status != 0 ) 10e485: 83 c4 10 add $0x10,%esp 10e488: 85 c0 test %eax,%eax 10e48a: 75 22 jne 10e4ae <== NEVER TAKEN * before device drivers are initialized. So we return via a base * filesystem image and nothing auto-mounted at this point. */ #endif } 10e48c: 8d 65 f4 lea -0xc(%ebp),%esp 10e48f: 5b pop %ebx 10e490: 5e pop %esi 10e491: 5f pop %edi 10e492: c9 leave 10e493: c3 ret /* * mount the first filesystem. */ if ( rtems_filesystem_mount_table_size == 0 ) rtems_fatal_error_occurred( 0xABCD0001 ); 10e494: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e497: 68 01 00 cd ab push $0xabcd0001 <== NOT EXECUTED 10e49c: e8 e3 c5 ff ff call 10aa84 <== NOT EXECUTED status = mount( &entry, mt->fs_ops, mt->fsoptions, mt->device, mt->mount_point ); if ( status == -1 ) rtems_fatal_error_occurred( 0xABCD0002 ); 10e4a1: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e4a4: 68 02 00 cd ab push $0xabcd0002 <== NOT EXECUTED 10e4a9: e8 d6 c5 ff ff call 10aa84 <== NOT EXECUTED * created that way by the IMFS. */ status = mkdir( "/dev", 0777); if ( status != 0 ) rtems_fatal_error_occurred( 0xABCD0003 ); 10e4ae: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e4b1: 68 03 00 cd ab push $0xabcd0003 <== NOT EXECUTED 10e4b6: e8 c9 c5 ff ff call 10aa84 <== NOT EXECUTED =============================================================================== 0010a74c : rtems_status_code rtems_interrupt_catch( rtems_isr_entry new_isr_handler, rtems_vector_number vector, rtems_isr_entry *old_isr_handler ) { 10a74c: 55 push %ebp <== NOT EXECUTED 10a74d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10a74f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a752: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10a755: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED if ( !_ISR_Is_vector_number_valid( vector ) ) 10a758: 81 7d 0c ff 00 00 00 cmpl $0xff,0xc(%ebp) <== NOT EXECUTED 10a75f: 77 23 ja 10a784 <== NOT EXECUTED return RTEMS_INVALID_NUMBER; if ( !_ISR_Is_valid_user_handler( (void *) new_isr_handler ) ) 10a761: 85 d2 test %edx,%edx <== NOT EXECUTED 10a763: 74 17 je 10a77c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; if ( !_ISR_Is_valid_user_handler( (void *) old_isr_handler ) ) 10a765: 85 c0 test %eax,%eax <== NOT EXECUTED 10a767: 74 13 je 10a77c <== NOT EXECUTED return RTEMS_INVALID_ADDRESS; _ISR_Install_vector( 10a769: 51 push %ecx <== NOT EXECUTED 10a76a: 50 push %eax <== NOT EXECUTED 10a76b: 52 push %edx <== NOT EXECUTED 10a76c: ff 75 0c pushl 0xc(%ebp) <== NOT EXECUTED 10a76f: e8 90 c5 ff ff call 106d04 <_CPU_ISR_install_vector><== NOT EXECUTED 10a774: 31 c0 xor %eax,%eax <== NOT EXECUTED 10a776: 83 c4 10 add $0x10,%esp <== NOT EXECUTED vector, (proc_ptr)new_isr_handler, (proc_ptr *)old_isr_handler ); return RTEMS_SUCCESSFUL; } 10a779: c9 leave <== NOT EXECUTED 10a77a: c3 ret <== NOT EXECUTED 10a77b: 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; 10a77c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED } 10a781: c9 leave <== NOT EXECUTED 10a782: c3 ret <== NOT EXECUTED 10a783: 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 ) ) 10a784: 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; } 10a789: c9 leave <== NOT EXECUTED 10a78a: c3 ret <== NOT EXECUTED =============================================================================== 00106d68 : rtems_status_code rtems_io_lookup_name( const char *name, rtems_driver_name_t *device_info ) { 106d68: 55 push %ebp <== NOT EXECUTED 106d69: 89 e5 mov %esp,%ebp <== NOT EXECUTED 106d6b: 57 push %edi <== NOT EXECUTED 106d6c: 56 push %esi <== NOT EXECUTED 106d6d: 53 push %ebx <== NOT EXECUTED 106d6e: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 106d71: 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 ); 106d74: 6a 01 push $0x1 <== NOT EXECUTED 106d76: 8d 75 e4 lea -0x1c(%ebp),%esi <== NOT EXECUTED 106d79: 56 push %esi <== NOT EXECUTED 106d7a: 6a 00 push $0x0 <== NOT EXECUTED 106d7c: 57 push %edi <== NOT EXECUTED 106d7d: e8 fa 01 00 00 call 106f7c <== NOT EXECUTED 106d82: 89 c3 mov %eax,%ebx <== NOT EXECUTED the_jnode = loc.node_access; 106d84: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 106d87: 89 45 e0 mov %eax,-0x20(%ebp) <== NOT EXECUTED if ( !loc.ops->node_type_h ) { 106d8a: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 106d8d: 8b 50 10 mov 0x10(%eax),%edx <== NOT EXECUTED 106d90: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106d93: 85 d2 test %edx,%edx <== NOT EXECUTED 106d95: 74 39 je 106dd0 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); rtems_set_errno_and_return_minus_one( ENOTSUP ); } node_type = (*loc.ops->node_type_h)( &loc ); 106d97: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106d9a: 56 push %esi <== NOT EXECUTED 106d9b: ff d2 call *%edx <== NOT EXECUTED if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) { 106d9d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106da0: 85 db test %ebx,%ebx <== NOT EXECUTED 106da2: 74 54 je 106df8 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 106da4: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 106da7: 85 c0 test %eax,%eax <== NOT EXECUTED 106da9: 0f 84 95 00 00 00 je 106e44 <== NOT EXECUTED 106daf: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 106db2: 85 c0 test %eax,%eax <== NOT EXECUTED 106db4: 0f 84 8a 00 00 00 je 106e44 <== NOT EXECUTED 106dba: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106dbd: 56 push %esi <== NOT EXECUTED 106dbe: ff d0 call *%eax <== NOT EXECUTED 106dc0: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED 106dc5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_filesystem_freenode( &loc ); #endif return RTEMS_SUCCESSFUL; } 106dc8: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106dcb: 5b pop %ebx <== NOT EXECUTED 106dcc: 5e pop %esi <== NOT EXECUTED 106dcd: 5f pop %edi <== NOT EXECUTED 106dce: c9 leave <== NOT EXECUTED 106dcf: 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 ); 106dd0: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 106dd3: 85 c0 test %eax,%eax <== NOT EXECUTED 106dd5: 74 09 je 106de0 <== NOT EXECUTED 106dd7: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106dda: 56 push %esi <== NOT EXECUTED 106ddb: ff d0 call *%eax <== NOT EXECUTED 106ddd: 83 c4 10 add $0x10,%esp <== NOT EXECUTED rtems_set_errno_and_return_minus_one( ENOTSUP ); 106de0: e8 3b 94 00 00 call 110220 <__errno> <== NOT EXECUTED 106de5: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 106deb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED rtems_filesystem_freenode( &loc ); #endif return RTEMS_SUCCESSFUL; } 106df0: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106df3: 5b pop %ebx <== NOT EXECUTED 106df4: 5e pop %esi <== NOT EXECUTED 106df5: 5f pop %edi <== NOT EXECUTED 106df6: c9 leave <== NOT EXECUTED 106df7: 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 ) { 106df8: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 106dfb: 75 a7 jne 106da4 <== NOT EXECUTED rtems_filesystem_freenode( &loc ); return RTEMS_UNSATISFIED; } device_info->device_name = (char *) name; 106dfd: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 106e00: 89 3a mov %edi,(%edx) <== NOT EXECUTED device_info->device_name_length = strlen( name ); 106e02: 31 c0 xor %eax,%eax <== NOT EXECUTED 106e04: b9 ff ff ff ff mov $0xffffffff,%ecx <== NOT EXECUTED 106e09: f2 ae repnz scas %es:(%edi),%al <== NOT EXECUTED 106e0b: f7 d1 not %ecx <== NOT EXECUTED 106e0d: 49 dec %ecx <== NOT EXECUTED 106e0e: 89 4a 04 mov %ecx,0x4(%edx) <== NOT EXECUTED device_info->major = the_jnode->info.device.major; 106e11: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 106e14: 8b 42 50 mov 0x50(%edx),%eax <== NOT EXECUTED 106e17: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 106e1a: 89 42 08 mov %eax,0x8(%edx) <== NOT EXECUTED device_info->minor = the_jnode->info.device.minor; 106e1d: 8b 55 e0 mov -0x20(%ebp),%edx <== NOT EXECUTED 106e20: 8b 42 54 mov 0x54(%edx),%eax <== NOT EXECUTED 106e23: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 106e26: 89 42 0c mov %eax,0xc(%edx) <== NOT EXECUTED rtems_filesystem_freenode( &loc ); 106e29: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 106e2c: 85 c0 test %eax,%eax <== NOT EXECUTED 106e2e: 74 24 je 106e54 <== NOT EXECUTED 106e30: 8b 40 1c mov 0x1c(%eax),%eax <== NOT EXECUTED 106e33: 85 c0 test %eax,%eax <== NOT EXECUTED 106e35: 74 1d je 106e54 <== NOT EXECUTED 106e37: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 106e3a: 56 push %esi <== NOT EXECUTED 106e3b: ff d0 call *%eax <== NOT EXECUTED 106e3d: 31 c0 xor %eax,%eax <== NOT EXECUTED 106e3f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 106e42: eb 84 jmp 106dc8 <== NOT EXECUTED 106e44: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED #endif return RTEMS_SUCCESSFUL; } 106e49: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 106e4c: 5b pop %ebx <== NOT EXECUTED 106e4d: 5e pop %esi <== NOT EXECUTED 106e4e: 5f pop %edi <== NOT EXECUTED 106e4f: c9 leave <== NOT EXECUTED 106e50: c3 ret <== NOT EXECUTED 106e51: 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 ); 106e54: 31 c0 xor %eax,%eax <== NOT EXECUTED 106e56: e9 6d ff ff ff jmp 106dc8 <== NOT EXECUTED =============================================================================== 0010b8d0 : 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 ) { 10b8d0: 55 push %ebp 10b8d1: 89 e5 mov %esp,%ebp 10b8d3: 57 push %edi 10b8d4: 56 push %esi 10b8d5: 53 push %ebx 10b8d6: 83 ec 04 sub $0x4,%esp 10b8d9: 8b 55 08 mov 0x8(%ebp),%edx 10b8dc: 8b 75 0c mov 0xc(%ebp),%esi 10b8df: 8b 5d 10 mov 0x10(%ebp),%ebx /* * Validate the pointer data and contents passed in */ if ( !driver_table ) 10b8e2: 85 f6 test %esi,%esi 10b8e4: 0f 84 c6 00 00 00 je 10b9b0 return RTEMS_INVALID_ADDRESS; if ( !registered_major ) 10b8ea: 85 db test %ebx,%ebx 10b8ec: 0f 84 be 00 00 00 je 10b9b0 return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 10b8f2: 8b 06 mov (%esi),%eax 10b8f4: 85 c0 test %eax,%eax 10b8f6: 0f 84 a8 00 00 00 je 10b9a4 return RTEMS_INVALID_ADDRESS; *registered_major = 0; 10b8fc: c7 03 00 00 00 00 movl $0x0,(%ebx) /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 10b902: a1 84 19 12 00 mov 0x121984,%eax 10b907: 39 d0 cmp %edx,%eax 10b909: 76 5d jbe 10b968 /* * Test for initialise/open being present to indicate the driver slot is * in use. */ if ( major == 0 ) { 10b90b: 85 d2 test %edx,%edx 10b90d: 75 65 jne 10b974 bool found = false; for ( major = _IO_Number_of_drivers - 1 ; major ; major-- ) { 10b90f: 89 c2 mov %eax,%edx 10b911: 4a dec %edx 10b912: 0f 84 80 00 00 00 je 10b998 <== NEVER TAKEN 10b918: 8d 04 40 lea (%eax,%eax,2),%eax 10b91b: 8d 04 c5 e8 ff ff ff lea -0x18(,%eax,8),%eax 10b922: 03 05 88 19 12 00 add 0x121988,%eax 10b928: eb 08 jmp 10b932 10b92a: 66 90 xchg %ax,%ax 10b92c: 83 e8 18 sub $0x18,%eax 10b92f: 4a dec %edx 10b930: 74 66 je 10b998 10b932: 89 c7 mov %eax,%edi if ( !_IO_Driver_address_table[major].initialization_entry && 10b934: 8b 08 mov (%eax),%ecx 10b936: 85 c9 test %ecx,%ecx 10b938: 75 f2 jne 10b92c 10b93a: 8b 48 04 mov 0x4(%eax),%ecx 10b93d: 85 c9 test %ecx,%ecx 10b93f: 75 eb jne 10b92c <== NEVER TAKEN 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; 10b941: b8 06 00 00 00 mov $0x6,%eax 10b946: 89 c1 mov %eax,%ecx 10b948: f3 a5 rep movsl %ds:(%esi),%es:(%edi) *registered_major = major; 10b94a: 89 13 mov %edx,(%ebx) return rtems_io_initialize( major, 0, NULL ); 10b94c: c7 45 10 00 00 00 00 movl $0x0,0x10(%ebp) 10b953: c7 45 0c 00 00 00 00 movl $0x0,0xc(%ebp) 10b95a: 89 55 08 mov %edx,0x8(%ebp) } 10b95d: 59 pop %ecx 10b95e: 5b pop %ebx 10b95f: 5e pop %esi 10b960: 5f pop %edi 10b961: c9 leave _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b962: e9 f1 fd ff ff jmp 10b758 10b967: 90 nop *registered_major = 0; /* * The requested major number is higher than what is configured. */ if ( major >= _IO_Number_of_drivers ) 10b968: b8 0a 00 00 00 mov $0xa,%eax _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); } 10b96d: 5a pop %edx 10b96e: 5b pop %ebx 10b96f: 5e pop %esi 10b970: 5f pop %edi 10b971: c9 leave 10b972: c3 ret 10b973: 90 nop if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 10b974: 8d 04 52 lea (%edx,%edx,2),%eax 10b977: 8d 3c c5 00 00 00 00 lea 0x0(,%eax,8),%edi 10b97e: 03 3d 88 19 12 00 add 0x121988,%edi 10b984: 8b 07 mov (%edi),%eax 10b986: 85 c0 test %eax,%eax 10b988: 74 32 je 10b9bc <== NEVER TAKEN _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b98a: b8 0c 00 00 00 mov $0xc,%eax } 10b98f: 5a pop %edx 10b990: 5b pop %ebx 10b991: 5e pop %esi 10b992: 5f pop %edi 10b993: c9 leave 10b994: c3 ret 10b995: 8d 76 00 lea 0x0(%esi),%esi _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b998: b8 05 00 00 00 mov $0x5,%eax } 10b99d: 5a pop %edx 10b99e: 5b pop %ebx 10b99f: 5e pop %esi 10b9a0: 5f pop %edi 10b9a1: c9 leave 10b9a2: c3 ret 10b9a3: 90 nop return RTEMS_INVALID_ADDRESS; if ( !registered_major ) return RTEMS_INVALID_ADDRESS; if ( !driver_table->initialization_entry && !driver_table->open_entry ) 10b9a4: 8b 7e 04 mov 0x4(%esi),%edi 10b9a7: 85 ff test %edi,%edi 10b9a9: 0f 85 4d ff ff ff jne 10b8fc <== NEVER TAKEN 10b9af: 90 nop _IO_Driver_address_table[major] = *driver_table; *registered_major = major; return rtems_io_initialize( major, 0, NULL ); 10b9b0: b8 09 00 00 00 mov $0x9,%eax } 10b9b5: 5a pop %edx 10b9b6: 5b pop %ebx 10b9b7: 5e pop %esi 10b9b8: 5f pop %edi 10b9b9: c9 leave 10b9ba: c3 ret 10b9bb: 90 nop if ( !found ) return RTEMS_TOO_MANY; } if ( _IO_Driver_address_table[major].initialization_entry || 10b9bc: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 10b9bf: 85 c0 test %eax,%eax <== NOT EXECUTED 10b9c1: 75 c7 jne 10b98a <== NOT EXECUTED 10b9c3: e9 79 ff ff ff jmp 10b941 <== NOT EXECUTED =============================================================================== 0010b9c8 : */ rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { 10b9c8: 55 push %ebp 10b9c9: 89 e5 mov %esp,%ebp 10b9cb: 57 push %edi 10b9cc: 83 ec 04 sub $0x4,%esp 10b9cf: 8b 45 08 mov 0x8(%ebp),%eax if ( major < _IO_Number_of_drivers ) { 10b9d2: 39 05 84 19 12 00 cmp %eax,0x121984 10b9d8: 77 0a ja 10b9e4 <== ALWAYS TAKEN 10b9da: b8 0d 00 00 00 mov $0xd,%eax <== NOT EXECUTED sizeof( rtems_driver_address_table ) ); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10b9df: 5a pop %edx <== NOT EXECUTED 10b9e0: 5f pop %edi <== NOT EXECUTED 10b9e1: c9 leave <== NOT EXECUTED 10b9e2: c3 ret <== NOT EXECUTED 10b9e3: 90 nop <== NOT EXECUTED rtems_status_code rtems_io_unregister_driver( rtems_device_major_number major ) { if ( major < _IO_Number_of_drivers ) { memset( 10b9e4: 8d 3c 40 lea (%eax,%eax,2),%edi 10b9e7: c1 e7 03 shl $0x3,%edi 10b9ea: 03 3d 88 19 12 00 add 0x121988,%edi 10b9f0: b9 18 00 00 00 mov $0x18,%ecx 10b9f5: 31 c0 xor %eax,%eax 10b9f7: f3 aa rep stos %al,%es:(%edi) 10b9f9: 31 c0 xor %eax,%eax sizeof( rtems_driver_address_table ) ); return RTEMS_SUCCESSFUL; } return RTEMS_UNSATISFIED; } 10b9fb: 5a pop %edx 10b9fc: 5f pop %edi 10b9fd: c9 leave 10b9fe: c3 ret =============================================================================== 0010c920 : #include #include void rtems_iterate_over_all_threads(rtems_per_thread_routine routine) { 10c920: 55 push %ebp 10c921: 89 e5 mov %esp,%ebp 10c923: 57 push %edi 10c924: 56 push %esi 10c925: 53 push %ebx 10c926: 83 ec 0c sub $0xc,%esp uint32_t i; uint32_t api_index; Thread_Control *the_thread; Objects_Information *information; if ( !routine ) 10c929: 8b 45 08 mov 0x8(%ebp),%eax 10c92c: 85 c0 test %eax,%eax 10c92e: 74 47 je 10c977 <== NEVER TAKEN return; 10c930: bf 01 00 00 00 mov $0x1,%edi for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { if ( !_Objects_Information_table[ api_index ] ) 10c935: 8b 04 bd 4c a6 12 00 mov 0x12a64c(,%edi,4),%eax 10c93c: 85 c0 test %eax,%eax 10c93e: 74 31 je 10c971 continue; information = _Objects_Information_table[ api_index ][ 1 ]; 10c940: 8b 70 04 mov 0x4(%eax),%esi if ( information ) { 10c943: 85 f6 test %esi,%esi 10c945: 74 2a je 10c971 <== NEVER TAKEN for ( i=1 ; i <= information->maximum ; i++ ) { 10c947: 66 83 7e 10 00 cmpw $0x0,0x10(%esi) 10c94c: 74 23 je 10c971 <== NEVER TAKEN 10c94e: bb 01 00 00 00 mov $0x1,%ebx 10c953: 90 nop the_thread = (Thread_Control *)information->local_table[ i ]; 10c954: 8b 46 1c mov 0x1c(%esi),%eax 10c957: 8b 04 98 mov (%eax,%ebx,4),%eax if ( !the_thread ) 10c95a: 85 c0 test %eax,%eax 10c95c: 74 0a je 10c968 <== NEVER TAKEN continue; (*routine)(the_thread); 10c95e: 83 ec 0c sub $0xc,%esp 10c961: 50 push %eax 10c962: ff 55 08 call *0x8(%ebp) 10c965: 83 c4 10 add $0x10,%esp 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++ ) { 10c968: 43 inc %ebx 10c969: 0f b7 46 10 movzwl 0x10(%esi),%eax 10c96d: 39 d8 cmp %ebx,%eax 10c96f: 73 e3 jae 10c954 if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) { 10c971: 47 inc %edi if ( !routine ) return; for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; 10c972: 83 ff 05 cmp $0x5,%edi 10c975: 75 be jne 10c935 (*routine)(the_thread); } } } } 10c977: 8d 65 f4 lea -0xc(%ebp),%esp 10c97a: 5b pop %ebx 10c97b: 5e pop %esi 10c97c: 5f pop %edi 10c97d: c9 leave 10c97e: c3 ret =============================================================================== 0010e82c : * 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 ) { 10e82c: 55 push %ebp 10e82d: 89 e5 mov %esp,%ebp 10e82f: 57 push %edi 10e830: 56 push %esi 10e831: 53 push %ebx 10e832: 83 ec 20 sub $0x20,%esp rtems_libio_t *iop, *next; rtems_status_code rc; rtems_id sema; rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10e835: 6a 00 push $0x0 10e837: 6a 00 push $0x0 10e839: ff 35 d8 e4 11 00 pushl 0x11e4d8 10e83f: e8 ac bb ff ff call 10a3f0 if (rtems_libio_iop_freelist) { 10e844: 8b 15 d4 e4 11 00 mov 0x11e4d4,%edx 10e84a: 83 c4 10 add $0x10,%esp 10e84d: 85 d2 test %edx,%edx 10e84f: 75 1b jne 10e86c } failed: iop = 0; done: 10e851: 31 db xor %ebx,%ebx rtems_semaphore_release( rtems_libio_semaphore ); 10e853: 83 ec 0c sub $0xc,%esp 10e856: ff 35 d8 e4 11 00 pushl 0x11e4d8 10e85c: e8 87 bc ff ff call 10a4e8 return iop; } 10e861: 89 d8 mov %ebx,%eax 10e863: 8d 65 f4 lea -0xc(%ebp),%esp 10e866: 5b pop %ebx 10e867: 5e pop %esi 10e868: 5f pop %edi 10e869: c9 leave 10e86a: c3 ret 10e86b: 90 nop rtems_id sema; rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); if (rtems_libio_iop_freelist) { rc = rtems_semaphore_create( 10e86c: 83 ec 0c sub $0xc,%esp 10e86f: 8d 45 f0 lea -0x10(%ebp),%eax 10e872: 50 push %eax 10e873: 6a 00 push $0x0 10e875: 6a 54 push $0x54 10e877: 6a 01 push $0x1 10e879: 89 d1 mov %edx,%ecx 10e87b: 2b 0d d0 e4 11 00 sub 0x11e4d0,%ecx 10e881: c1 f9 02 sar $0x2,%ecx 10e884: 8d 14 89 lea (%ecx,%ecx,4),%edx 10e887: 8d 14 92 lea (%edx,%edx,4),%edx 10e88a: 89 d0 mov %edx,%eax 10e88c: c1 e0 06 shl $0x6,%eax 10e88f: 29 d0 sub %edx,%eax 10e891: 89 c2 mov %eax,%edx 10e893: c1 e2 0c shl $0xc,%edx 10e896: 01 d0 add %edx,%eax 10e898: 8d 04 81 lea (%ecx,%eax,4),%eax 10e89b: 8d 04 41 lea (%ecx,%eax,2),%eax 10e89e: c1 e0 04 shl $0x4,%eax 10e8a1: 01 c8 add %ecx,%eax 10e8a3: 8d 04 81 lea (%ecx,%eax,4),%eax 10e8a6: 0d 00 49 42 4c or $0x4c424900,%eax 10e8ab: 50 push %eax 10e8ac: e8 bf b8 ff ff call 10a170 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &sema ); if (rc != RTEMS_SUCCESSFUL) 10e8b1: 83 c4 20 add $0x20,%esp 10e8b4: 85 c0 test %eax,%eax 10e8b6: 75 99 jne 10e851 <== NEVER TAKEN goto failed; iop = rtems_libio_iop_freelist; 10e8b8: 8b 1d d4 e4 11 00 mov 0x11e4d4,%ebx next = iop->data1; 10e8be: 8b 73 28 mov 0x28(%ebx),%esi (void) memset( iop, 0, sizeof(rtems_libio_t) ); 10e8c1: b9 34 00 00 00 mov $0x34,%ecx 10e8c6: 31 d2 xor %edx,%edx 10e8c8: 89 df mov %ebx,%edi 10e8ca: 88 d0 mov %dl,%al 10e8cc: f3 aa rep stos %al,%es:(%edi) iop->flags = LIBIO_FLAGS_OPEN; 10e8ce: c7 43 0c 00 01 00 00 movl $0x100,0xc(%ebx) iop->sem = sema; 10e8d5: 8b 55 f0 mov -0x10(%ebp),%edx 10e8d8: 89 53 20 mov %edx,0x20(%ebx) rtems_libio_iop_freelist = next; 10e8db: 89 35 d4 e4 11 00 mov %esi,0x11e4d4 10e8e1: e9 6d ff ff ff jmp 10e853 =============================================================================== 0010e7d4 : */ void rtems_libio_free( rtems_libio_t *iop ) { 10e7d4: 55 push %ebp 10e7d5: 89 e5 mov %esp,%ebp 10e7d7: 53 push %ebx 10e7d8: 83 ec 08 sub $0x8,%esp 10e7db: 8b 5d 08 mov 0x8(%ebp),%ebx rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT ); 10e7de: 6a 00 push $0x0 10e7e0: 6a 00 push $0x0 10e7e2: ff 35 d8 e4 11 00 pushl 0x11e4d8 10e7e8: e8 03 bc ff ff call 10a3f0 if (iop->sem) 10e7ed: 8b 43 20 mov 0x20(%ebx),%eax 10e7f0: 83 c4 10 add $0x10,%esp 10e7f3: 85 c0 test %eax,%eax 10e7f5: 74 0c je 10e803 <== NEVER TAKEN rtems_semaphore_delete(iop->sem); 10e7f7: 83 ec 0c sub $0xc,%esp 10e7fa: 50 push %eax 10e7fb: e8 4c bb ff ff call 10a34c 10e800: 83 c4 10 add $0x10,%esp iop->flags &= ~LIBIO_FLAGS_OPEN; 10e803: 81 63 0c ff fe ff ff andl $0xfffffeff,0xc(%ebx) iop->data1 = rtems_libio_iop_freelist; 10e80a: a1 d4 e4 11 00 mov 0x11e4d4,%eax 10e80f: 89 43 28 mov %eax,0x28(%ebx) rtems_libio_iop_freelist = iop; 10e812: 89 1d d4 e4 11 00 mov %ebx,0x11e4d4 rtems_semaphore_release(rtems_libio_semaphore); 10e818: a1 d8 e4 11 00 mov 0x11e4d8,%eax 10e81d: 89 45 08 mov %eax,0x8(%ebp) } 10e820: 8b 5d fc mov -0x4(%ebp),%ebx 10e823: c9 leave iop->flags &= ~LIBIO_FLAGS_OPEN; iop->data1 = rtems_libio_iop_freelist; rtems_libio_iop_freelist = iop; rtems_semaphore_release(rtems_libio_semaphore); 10e824: e9 bf bc ff ff jmp 10a4e8 =============================================================================== 0010713c : * * Called by BSP startup code to initialize the libio subsystem. */ void rtems_libio_init( void ) { 10713c: 55 push %ebp 10713d: 89 e5 mov %esp,%ebp 10713f: 53 push %ebx 107140: 83 ec 04 sub $0x4,%esp rtems_status_code rc; int i; rtems_libio_t *iop; if (rtems_libio_number_iops > 0) 107143: a1 40 a0 11 00 mov 0x11a040,%eax 107148: 85 c0 test %eax,%eax 10714a: 74 50 je 10719c { rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops, 10714c: 83 ec 08 sub $0x8,%esp 10714f: 6a 34 push $0x34 107151: 50 push %eax 107152: e8 65 73 00 00 call 10e4bc 107157: 89 c3 mov %eax,%ebx 107159: 89 1d d0 e4 11 00 mov %ebx,0x11e4d0 sizeof(rtems_libio_t)); if (rtems_libio_iops == NULL) 10715f: 83 c4 10 add $0x10,%esp 107162: 85 db test %ebx,%ebx 107164: 74 5e je 1071c4 <== NEVER TAKEN rtems_fatal_error_occurred(RTEMS_NO_MEMORY); iop = rtems_libio_iop_freelist = rtems_libio_iops; 107166: 89 1d d4 e4 11 00 mov %ebx,0x11e4d4 for (i = 0 ; i < (rtems_libio_number_iops - 1) ; i++, iop++) 10716c: 8b 0d 40 a0 11 00 mov 0x11a040,%ecx 107172: 83 f9 01 cmp $0x1,%ecx 107175: 74 1e je 107195 <== NEVER TAKEN 107177: 8d 43 34 lea 0x34(%ebx),%eax 10717a: ba 01 00 00 00 mov $0x1,%edx 10717f: 90 nop iop->data1 = iop + 1; 107180: 89 40 f4 mov %eax,-0xc(%eax) 107183: 42 inc %edx 107184: 83 c0 34 add $0x34,%eax 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++) 107187: 39 ca cmp %ecx,%edx 107189: 75 f5 jne 107180 10718b: 8d 04 52 lea (%edx,%edx,2),%eax 10718e: 8d 04 82 lea (%edx,%eax,4),%eax 107191: 8d 44 83 cc lea -0x34(%ebx,%eax,4),%eax iop->data1 = iop + 1; iop->data1 = NULL; 107195: c7 40 28 00 00 00 00 movl $0x0,0x28(%eax) /* * Create the binary semaphore used to provide mutual exclusion * on the IOP Table. */ rc = rtems_semaphore_create( 10719c: 83 ec 0c sub $0xc,%esp 10719f: 68 d8 e4 11 00 push $0x11e4d8 1071a4: 6a 00 push $0x0 1071a6: 6a 54 push $0x54 1071a8: 6a 01 push $0x1 1071aa: 68 4f 49 42 4c push $0x4c42494f 1071af: e8 bc 2f 00 00 call 10a170 1, RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &rtems_libio_semaphore ); if ( rc != RTEMS_SUCCESSFUL ) 1071b4: 83 c4 20 add $0x20,%esp 1071b7: 85 c0 test %eax,%eax 1071b9: 75 13 jne 1071ce <== NEVER TAKEN /* * Initialize the base file system infrastructure. */ rtems_filesystem_initialize(); } 1071bb: 8b 5d fc mov -0x4(%ebp),%ebx 1071be: c9 leave /* * Initialize the base file system infrastructure. */ rtems_filesystem_initialize(); 1071bf: e9 04 72 00 00 jmp 10e3c8 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); 1071c4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1071c7: 6a 1a push $0x1a <== NOT EXECUTED 1071c9: e8 b6 38 00 00 call 10aa84 <== 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 ); 1071ce: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1071d1: 50 push %eax <== NOT EXECUTED 1071d2: e8 ad 38 00 00 call 10aa84 <== NOT EXECUTED =============================================================================== 0010e70c : */ int rtems_libio_is_file_open( void *node_access ) { 10e70c: 55 push %ebp <== NOT EXECUTED 10e70d: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e70f: 53 push %ebx <== NOT EXECUTED 10e710: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e713: 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 ); 10e716: 6a 00 push $0x0 <== NOT EXECUTED 10e718: 6a 00 push $0x0 <== NOT EXECUTED 10e71a: ff 35 d8 e4 11 00 pushl 0x11e4d8 <== NOT EXECUTED 10e720: e8 cb bc ff ff call 10a3f0 <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10e725: 8b 15 d0 e4 11 00 mov 0x11e4d0,%edx <== NOT EXECUTED 10e72b: 8b 0d 40 a0 11 00 mov 0x11a040,%ecx <== NOT EXECUTED 10e731: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e734: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10e736: 74 17 je 10e74f <== NOT EXECUTED 10e738: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e73a: eb 03 jmp 10e73f <== NOT EXECUTED 10e73c: 83 c2 34 add $0x34,%edx <== NOT EXECUTED if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) { 10e73f: f6 42 0d 01 testb $0x1,0xd(%edx) <== NOT EXECUTED 10e743: 74 05 je 10e74a <== NOT EXECUTED /* * Check if this node is under the file system that we * are trying to dismount. */ if ( iop->pathinfo.node_access == node_access ) { 10e745: 39 5a 10 cmp %ebx,0x10(%edx) <== NOT EXECUTED 10e748: 74 1e je 10e768 <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10e74a: 40 inc %eax <== NOT EXECUTED 10e74b: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10e74d: 72 ed jb 10e73c <== NOT EXECUTED 10e74f: 31 db xor %ebx,%ebx <== NOT EXECUTED break; } } } rtems_semaphore_release( rtems_libio_semaphore ); 10e751: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e754: ff 35 d8 e4 11 00 pushl 0x11e4d8 <== NOT EXECUTED 10e75a: e8 89 bd ff ff call 10a4e8 <== NOT EXECUTED return result; } 10e75f: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e761: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e764: c9 leave <== NOT EXECUTED 10e765: c3 ret <== NOT EXECUTED 10e766: 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++){ 10e768: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10e76d: eb e2 jmp 10e751 <== NOT EXECUTED =============================================================================== 0010e770 : */ int rtems_libio_is_open_files_in_fs( rtems_filesystem_mount_table_entry_t * fs_mt_entry ) { 10e770: 55 push %ebp <== NOT EXECUTED 10e771: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e773: 53 push %ebx <== NOT EXECUTED 10e774: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10e777: 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 ); 10e77a: 6a 00 push $0x0 <== NOT EXECUTED 10e77c: 6a 00 push $0x0 <== NOT EXECUTED 10e77e: ff 35 d8 e4 11 00 pushl 0x11e4d8 <== NOT EXECUTED 10e784: e8 67 bc ff ff call 10a3f0 <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10e789: 8b 15 d0 e4 11 00 mov 0x11e4d0,%edx <== NOT EXECUTED 10e78f: 8b 0d 40 a0 11 00 mov 0x11a040,%ecx <== NOT EXECUTED 10e795: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10e798: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10e79a: 74 17 je 10e7b3 <== NOT EXECUTED 10e79c: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e79e: eb 03 jmp 10e7a3 <== NOT EXECUTED 10e7a0: 83 c2 34 add $0x34,%edx <== NOT EXECUTED if ((iop->flags & LIBIO_FLAGS_OPEN) != 0) { 10e7a3: f6 42 0d 01 testb $0x1,0xd(%edx) <== NOT EXECUTED 10e7a7: 74 05 je 10e7ae <== 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 ) { 10e7a9: 39 5a 1c cmp %ebx,0x1c(%edx) <== NOT EXECUTED 10e7ac: 74 1e je 10e7cc <== NOT EXECUTED /* * Look for any active file descriptor entry. */ for (iop=rtems_libio_iops,i=0; i < rtems_libio_number_iops; iop++, i++){ 10e7ae: 40 inc %eax <== NOT EXECUTED 10e7af: 39 c8 cmp %ecx,%eax <== NOT EXECUTED 10e7b1: 72 ed jb 10e7a0 <== NOT EXECUTED 10e7b3: 31 db xor %ebx,%ebx <== NOT EXECUTED break; } } } rtems_semaphore_release( rtems_libio_semaphore ); 10e7b5: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10e7b8: ff 35 d8 e4 11 00 pushl 0x11e4d8 <== NOT EXECUTED 10e7be: e8 25 bd ff ff call 10a4e8 <== NOT EXECUTED return result; } 10e7c3: 89 d8 mov %ebx,%eax <== NOT EXECUTED 10e7c5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10e7c8: c9 leave <== NOT EXECUTED 10e7c9: c3 ret <== NOT EXECUTED 10e7ca: 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++){ 10e7cc: bb 01 00 00 00 mov $0x1,%ebx <== NOT EXECUTED 10e7d1: eb e2 jmp 10e7b5 <== NOT EXECUTED =============================================================================== 0010e6cc : */ uint32_t rtems_libio_to_fcntl_flags( uint32_t flags ) { 10e6cc: 55 push %ebp <== NOT EXECUTED 10e6cd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 10e6cf: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10e6d2: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e6d4: 83 e0 06 and $0x6,%eax <== NOT EXECUTED 10e6d7: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 10e6da: 74 2c je 10e708 <== NOT EXECUTED fcntl_flags |= O_RDWR; } else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) { 10e6dc: f6 c2 02 test $0x2,%dl <== NOT EXECUTED 10e6df: 75 23 jne 10e704 <== NOT EXECUTED 10e6e1: 89 d0 mov %edx,%eax <== NOT EXECUTED 10e6e3: c1 e8 02 shr $0x2,%eax <== NOT EXECUTED 10e6e6: 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 ) { 10e6e9: f6 c2 01 test $0x1,%dl <== NOT EXECUTED 10e6ec: 74 03 je 10e6f1 <== NOT EXECUTED fcntl_flags |= O_NONBLOCK; 10e6ee: 80 cc 40 or $0x40,%ah <== NOT EXECUTED } if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) { 10e6f1: f6 c6 02 test $0x2,%dh <== NOT EXECUTED 10e6f4: 74 03 je 10e6f9 <== NOT EXECUTED fcntl_flags |= O_APPEND; 10e6f6: 83 c8 08 or $0x8,%eax <== NOT EXECUTED } if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) { 10e6f9: 80 e6 04 and $0x4,%dh <== NOT EXECUTED 10e6fc: 74 03 je 10e701 <== NOT EXECUTED fcntl_flags |= O_CREAT; 10e6fe: 80 cc 02 or $0x2,%ah <== NOT EXECUTED } return fcntl_flags; } 10e701: c9 leave <== NOT EXECUTED 10e702: c3 ret <== NOT EXECUTED 10e703: 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) { 10e704: 31 c0 xor %eax,%eax <== NOT EXECUTED 10e706: eb e1 jmp 10e6e9 <== NOT EXECUTED uint32_t flags ) { uint32_t fcntl_flags = 0; if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) { 10e708: b0 02 mov $0x2,%al <== NOT EXECUTED 10e70a: eb dd jmp 10e6e9 <== NOT EXECUTED =============================================================================== 001094e0 : int rtems_memalign( void **pointer, size_t alignment, size_t size ) { 1094e0: 55 push %ebp 1094e1: 89 e5 mov %esp,%ebp 1094e3: 56 push %esi 1094e4: 53 push %ebx 1094e5: 8b 75 08 mov 0x8(%ebp),%esi void *return_this; /* * Parameter error checks */ if ( !pointer ) 1094e8: 85 f6 test %esi,%esi 1094ea: 74 55 je 109541 return EINVAL; *pointer = NULL; 1094ec: c7 06 00 00 00 00 movl $0x0,(%esi) /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 1094f2: 83 3d c4 3e 12 00 03 cmpl $0x3,0x123ec4 1094f9: 74 3d je 109538 <== ALWAYS TAKEN /* * * If some free's have been deferred, then do them now. */ malloc_deferred_frees_process(); 1094fb: e8 d0 f0 ff ff call 1085d0 /* * Perform the aligned allocation requested */ return_this = _Protected_heap_Allocate_aligned( 109500: 50 push %eax 109501: ff 75 0c pushl 0xc(%ebp) 109504: ff 75 10 pushl 0x10(%ebp) 109507: 68 a0 3b 12 00 push $0x123ba0 10950c: e8 e3 46 00 00 call 10dbf4 <_Protected_heap_Allocate_aligned> 109511: 89 c3 mov %eax,%ebx &RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 109513: 83 c4 10 add $0x10,%esp 109516: 85 c0 test %eax,%eax 109518: 74 36 je 109550 return ENOMEM; /* * If configured, update the more involved statistics */ if ( rtems_malloc_statistics_helpers ) 10951a: a1 e4 1b 12 00 mov 0x121be4,%eax 10951f: 85 c0 test %eax,%eax 109521: 74 0a je 10952d <== ALWAYS TAKEN (*rtems_malloc_statistics_helpers->at_malloc)(pointer); 109523: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109526: 56 push %esi <== NOT EXECUTED 109527: ff 50 04 call *0x4(%eax) <== NOT EXECUTED 10952a: 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; 10952d: 89 1e mov %ebx,(%esi) 10952f: 31 c0 xor %eax,%eax return 0; } 109531: 8d 65 f8 lea -0x8(%ebp),%esp 109534: 5b pop %ebx 109535: 5e pop %esi 109536: c9 leave 109537: c3 ret *pointer = NULL; /* * Do not attempt to allocate memory if not in correct system state. */ if ( _System_state_Is_up(_System_state_Get()) && 109538: e8 3b f0 ff ff call 108578 10953d: 84 c0 test %al,%al 10953f: 75 ba jne 1094fb <== ALWAYS TAKEN if (rtems_malloc_boundary_helpers) (*rtems_malloc_boundary_helpers->at_malloc)(return_this, size); #endif *pointer = return_this; return 0; 109541: b8 16 00 00 00 mov $0x16,%eax } 109546: 8d 65 f8 lea -0x8(%ebp),%esp 109549: 5b pop %ebx 10954a: 5e pop %esi 10954b: c9 leave 10954c: c3 ret 10954d: 8d 76 00 lea 0x0(%esi),%esi return_this = _Protected_heap_Allocate_aligned( &RTEMS_Malloc_Heap, size, alignment ); if ( !return_this ) 109550: b8 0c 00 00 00 mov $0xc,%eax 109555: eb da jmp 109531 =============================================================================== 0011236c : Objects_Id id, const void *buffer, size_t size, uint32_t *count ) { 11236c: 55 push %ebp 11236d: 89 e5 mov %esp,%ebp 11236f: 57 push %edi 112370: 56 push %esi 112371: 53 push %ebx 112372: 83 ec 1c sub $0x1c,%esp 112375: 8b 7d 08 mov 0x8(%ebp),%edi 112378: 8b 75 0c mov 0xc(%ebp),%esi 11237b: 8b 5d 14 mov 0x14(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status core_status; if ( !buffer ) 11237e: 85 f6 test %esi,%esi 112380: 74 62 je 1123e4 return RTEMS_INVALID_ADDRESS; if ( !count ) 112382: 85 db test %ebx,%ebx 112384: 74 5e je 1123e4 * @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, 112386: 51 push %ecx 112387: 8d 45 f0 lea -0x10(%ebp),%eax 11238a: 50 push %eax 11238b: 57 push %edi 11238c: 68 60 5d 13 00 push $0x135d60 112391: e8 4a 48 00 00 call 116be0 <_Objects_Get> return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 112396: 83 c4 10 add $0x10,%esp 112399: 8b 55 f0 mov -0x10(%ebp),%edx 11239c: 85 d2 test %edx,%edx 11239e: 74 10 je 1123b0 1123a0: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1123a5: 8d 65 f4 lea -0xc(%ebp),%esp 1123a8: 5b pop %ebx 1123a9: 5e pop %esi 1123aa: 5f pop %edi 1123ab: c9 leave 1123ac: c3 ret 1123ad: 8d 76 00 lea 0x0(%esi),%esi the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: core_status = _CORE_message_queue_Broadcast( 1123b0: 83 ec 08 sub $0x8,%esp 1123b3: 53 push %ebx 1123b4: 6a 00 push $0x0 1123b6: 57 push %edi 1123b7: ff 75 10 pushl 0x10(%ebp) 1123ba: 56 push %esi 1123bb: 83 c0 14 add $0x14,%eax 1123be: 50 push %eax 1123bf: e8 78 31 00 00 call 11553c <_CORE_message_queue_Broadcast> 1123c4: 89 c3 mov %eax,%ebx NULL, #endif count ); _Thread_Enable_dispatch(); 1123c6: 83 c4 20 add $0x20,%esp 1123c9: e8 56 50 00 00 call 117424 <_Thread_Enable_dispatch> return 1123ce: 83 ec 0c sub $0xc,%esp 1123d1: 53 push %ebx 1123d2: e8 5d 03 00 00 call 112734 <_Message_queue_Translate_core_message_queue_return_code> 1123d7: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1123da: 8d 65 f4 lea -0xc(%ebp),%esp 1123dd: 5b pop %ebx 1123de: 5e pop %esi 1123df: 5f pop %edi 1123e0: c9 leave 1123e1: c3 ret 1123e2: 66 90 xchg %ax,%ax #endif count ); _Thread_Enable_dispatch(); return 1123e4: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1123e9: 8d 65 f4 lea -0xc(%ebp),%esp 1123ec: 5b pop %ebx 1123ed: 5e pop %esi 1123ee: 5f pop %edi 1123ef: c9 leave 1123f0: c3 ret =============================================================================== 001123f4 : uint32_t count, size_t max_message_size, rtems_attribute attribute_set, Objects_Id *id ) { 1123f4: 55 push %ebp 1123f5: 89 e5 mov %esp,%ebp 1123f7: 56 push %esi 1123f8: 53 push %ebx 1123f9: 83 ec 10 sub $0x10,%esp 1123fc: 8b 75 08 mov 0x8(%ebp),%esi CORE_message_queue_Attributes the_msgq_attributes; #if defined(RTEMS_MULTIPROCESSING) bool is_global; #endif if ( !rtems_is_name_valid( name ) ) 1123ff: 85 f6 test %esi,%esi 112401: 74 31 je 112434 return RTEMS_INVALID_NAME; if ( !id ) 112403: 8b 4d 18 mov 0x18(%ebp),%ecx 112406: 85 c9 test %ecx,%ecx 112408: 0f 84 92 00 00 00 je 1124a0 <== NEVER TAKEN if ( (is_global = _Attributes_Is_global( attribute_set ) ) && !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) 11240e: 8b 55 0c mov 0xc(%ebp),%edx 112411: 85 d2 test %edx,%edx 112413: 74 13 je 112428 <== NEVER TAKEN return RTEMS_INVALID_NUMBER; if ( max_message_size == 0 ) 112415: 8b 45 10 mov 0x10(%ebp),%eax 112418: 85 c0 test %eax,%eax 11241a: 75 24 jne 112440 <== ALWAYS TAKEN 11241c: b8 08 00 00 00 mov $0x8,%eax <== NOT EXECUTED ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 112421: 8d 65 f8 lea -0x8(%ebp),%esp 112424: 5b pop %ebx 112425: 5e pop %esi 112426: c9 leave 112427: c3 ret if ( (is_global = _Attributes_Is_global( attribute_set ) ) && !_System_state_Is_multiprocessing ) return RTEMS_MP_NOT_CONFIGURED; #endif if ( count == 0 ) 112428: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 11242d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 112430: 5b pop %ebx <== NOT EXECUTED 112431: 5e pop %esi <== NOT EXECUTED 112432: c9 leave <== NOT EXECUTED 112433: 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 ) ) 112434: b8 03 00 00 00 mov $0x3,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 112439: 8d 65 f8 lea -0x8(%ebp),%esp 11243c: 5b pop %ebx 11243d: 5e pop %esi 11243e: c9 leave 11243f: c3 ret /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 112440: a1 38 5a 13 00 mov 0x135a38,%eax 112445: 40 inc %eax 112446: a3 38 5a 13 00 mov %eax,0x135a38 #endif #endif _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); 11244b: e8 dc 7d 00 00 call 11a22c <_Message_queue_Allocate> 112450: 89 c3 mov %eax,%ebx if ( !the_message_queue ) { 112452: 85 c0 test %eax,%eax 112454: 74 7a je 1124d0 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_message_queue->attribute_set = attribute_set; 112456: 8b 45 14 mov 0x14(%ebp),%eax 112459: 89 43 10 mov %eax,0x10(%ebx) if (_Attributes_Is_priority( attribute_set ) ) the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY; 11245c: a8 04 test $0x4,%al 11245e: 0f 95 c0 setne %al 112461: 0f b6 c0 movzbl %al,%eax 112464: 89 45 f4 mov %eax,-0xc(%ebp) else the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO; if ( ! _CORE_message_queue_Initialize( 112467: ff 75 10 pushl 0x10(%ebp) 11246a: ff 75 0c pushl 0xc(%ebp) 11246d: 8d 45 f4 lea -0xc(%ebp),%eax 112470: 50 push %eax 112471: 8d 43 14 lea 0x14(%ebx),%eax 112474: 50 push %eax 112475: e8 e2 31 00 00 call 11565c <_CORE_message_queue_Initialize> 11247a: 83 c4 10 add $0x10,%esp 11247d: 84 c0 test %al,%al 11247f: 75 2b jne 1124ac * @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, 112481: 83 ec 08 sub $0x8,%esp 112484: 53 push %ebx 112485: 68 60 5d 13 00 push $0x135d60 11248a: e8 dd 45 00 00 call 116a6c <_Objects_Free> _Objects_MP_Close( &_Message_queue_Information, the_message_queue->Object.id); #endif _Message_queue_Free( the_message_queue ); _Thread_Enable_dispatch(); 11248f: e8 90 4f 00 00 call 117424 <_Thread_Enable_dispatch> 112494: b8 0d 00 00 00 mov $0xd,%eax 112499: 83 c4 10 add $0x10,%esp 11249c: eb 83 jmp 112421 11249e: 66 90 xchg %ax,%ax #endif if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 1124a0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 1124a5: e9 77 ff ff ff jmp 112421 <== NOT EXECUTED 1124aa: 66 90 xchg %ax,%ax <== NOT EXECUTED 1124ac: 8b 4b 08 mov 0x8(%ebx),%ecx 1124af: 0f b7 d1 movzwl %cx,%edx 1124b2: a1 7c 5d 13 00 mov 0x135d7c,%eax 1124b7: 89 1c 90 mov %ebx,(%eax,%edx,4) 1124ba: 89 73 0c mov %esi,0xc(%ebx) &_Message_queue_Information, &the_message_queue->Object, (Objects_Name) name ); *id = the_message_queue->Object.id; 1124bd: 8b 45 18 mov 0x18(%ebp),%eax 1124c0: 89 08 mov %ecx,(%eax) name, 0 ); #endif _Thread_Enable_dispatch(); 1124c2: e8 5d 4f 00 00 call 117424 <_Thread_Enable_dispatch> 1124c7: 31 c0 xor %eax,%eax 1124c9: e9 53 ff ff ff jmp 112421 1124ce: 66 90 xchg %ax,%ax _Thread_Disable_dispatch(); /* protects object pointer */ the_message_queue = _Message_queue_Allocate(); if ( !the_message_queue ) { _Thread_Enable_dispatch(); 1124d0: e8 4f 4f 00 00 call 117424 <_Thread_Enable_dispatch> 1124d5: b8 05 00 00 00 mov $0x5,%eax 1124da: e9 42 ff ff ff jmp 112421 =============================================================================== 001124e0 : */ rtems_status_code rtems_message_queue_delete( Objects_Id id ) { 1124e0: 55 push %ebp 1124e1: 89 e5 mov %esp,%ebp 1124e3: 53 push %ebx 1124e4: 83 ec 18 sub $0x18,%esp * @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, 1124e7: 8d 45 f8 lea -0x8(%ebp),%eax 1124ea: 50 push %eax 1124eb: ff 75 08 pushl 0x8(%ebp) 1124ee: 68 60 5d 13 00 push $0x135d60 1124f3: e8 e8 46 00 00 call 116be0 <_Objects_Get> 1124f8: 89 c3 mov %eax,%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 1124fa: 83 c4 10 add $0x10,%esp 1124fd: 8b 4d f8 mov -0x8(%ebp),%ecx 112500: 85 c9 test %ecx,%ecx 112502: 75 3c jne 112540 case OBJECTS_LOCAL: _Objects_Close( &_Message_queue_Information, 112504: 83 ec 08 sub $0x8,%esp 112507: 50 push %eax 112508: 68 60 5d 13 00 push $0x135d60 11250d: e8 1a 42 00 00 call 11672c <_Objects_Close> &the_message_queue->Object ); _CORE_message_queue_Close( 112512: 83 c4 0c add $0xc,%esp 112515: 6a 05 push $0x5 112517: 6a 00 push $0x0 112519: 8d 43 14 lea 0x14(%ebx),%eax 11251c: 50 push %eax 11251d: e8 96 30 00 00 call 1155b8 <_CORE_message_queue_Close> * @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, 112522: 58 pop %eax 112523: 5a pop %edx 112524: 53 push %ebx 112525: 68 60 5d 13 00 push $0x135d60 11252a: e8 3d 45 00 00 call 116a6c <_Objects_Free> 0, /* Not used */ 0 ); } #endif _Thread_Enable_dispatch(); 11252f: e8 f0 4e 00 00 call 117424 <_Thread_Enable_dispatch> 112534: 31 c0 xor %eax,%eax 112536: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112539: 8b 5d fc mov -0x4(%ebp),%ebx 11253c: c9 leave 11253d: c3 ret 11253e: 66 90 xchg %ax,%ax { register Message_queue_Control *the_message_queue; Objects_Locations location; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 112540: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112545: 8b 5d fc mov -0x4(%ebp),%ebx 112548: c9 leave 112549: c3 ret =============================================================================== 0011254c : rtems_status_code rtems_message_queue_flush( Objects_Id id, uint32_t *count ) { 11254c: 55 push %ebp 11254d: 89 e5 mov %esp,%ebp 11254f: 53 push %ebx 112550: 83 ec 14 sub $0x14,%esp 112553: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 112556: 85 db test %ebx,%ebx 112558: 74 46 je 1125a0 <== NEVER TAKEN * @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, 11255a: 51 push %ecx 11255b: 8d 45 f8 lea -0x8(%ebp),%eax 11255e: 50 push %eax 11255f: ff 75 08 pushl 0x8(%ebp) 112562: 68 60 5d 13 00 push $0x135d60 112567: e8 74 46 00 00 call 116be0 <_Objects_Get> return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 11256c: 83 c4 10 add $0x10,%esp 11256f: 8b 55 f8 mov -0x8(%ebp),%edx 112572: 85 d2 test %edx,%edx 112574: 74 0a je 112580 112576: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11257b: 8b 5d fc mov -0x4(%ebp),%ebx 11257e: c9 leave 11257f: c3 ret the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *count = _CORE_message_queue_Flush( &the_message_queue->message_queue ); 112580: 83 ec 0c sub $0xc,%esp 112583: 83 c0 14 add $0x14,%eax 112586: 50 push %eax 112587: e8 68 30 00 00 call 1155f4 <_CORE_message_queue_Flush> 11258c: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 11258e: e8 91 4e 00 00 call 117424 <_Thread_Enable_dispatch> 112593: 31 c0 xor %eax,%eax 112595: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112598: 8b 5d fc mov -0x4(%ebp),%ebx 11259b: c9 leave 11259c: c3 ret 11259d: 8d 76 00 lea 0x0(%esi),%esi ) { register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 1125a0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1125a5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1125a8: c9 leave <== NOT EXECUTED 1125a9: c3 ret <== NOT EXECUTED =============================================================================== 001125ac : rtems_status_code rtems_message_queue_get_number_pending( Objects_Id id, uint32_t *count ) { 1125ac: 55 push %ebp 1125ad: 89 e5 mov %esp,%ebp 1125af: 53 push %ebx 1125b0: 83 ec 14 sub $0x14,%esp 1125b3: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 1125b6: 85 db test %ebx,%ebx 1125b8: 74 3a je 1125f4 <== NEVER TAKEN 1125ba: 51 push %ecx 1125bb: 8d 45 f8 lea -0x8(%ebp),%eax 1125be: 50 push %eax 1125bf: ff 75 08 pushl 0x8(%ebp) 1125c2: 68 60 5d 13 00 push $0x135d60 1125c7: e8 14 46 00 00 call 116be0 <_Objects_Get> return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 1125cc: 83 c4 10 add $0x10,%esp 1125cf: 8b 55 f8 mov -0x8(%ebp),%edx 1125d2: 85 d2 test %edx,%edx 1125d4: 74 0a je 1125e0 1125d6: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1125db: 8b 5d fc mov -0x4(%ebp),%ebx 1125de: c9 leave 1125df: c3 ret the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *count = the_message_queue->message_queue.number_of_pending_messages; 1125e0: 8b 40 5c mov 0x5c(%eax),%eax 1125e3: 89 03 mov %eax,(%ebx) _Thread_Enable_dispatch(); 1125e5: e8 3a 4e 00 00 call 117424 <_Thread_Enable_dispatch> 1125ea: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1125ec: 8b 5d fc mov -0x4(%ebp),%ebx 1125ef: c9 leave 1125f0: c3 ret 1125f1: 8d 76 00 lea 0x0(%esi),%esi ) { register Message_queue_Control *the_message_queue; Objects_Locations location; if ( !count ) 1125f4: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1125f9: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1125fc: c9 leave <== NOT EXECUTED 1125fd: c3 ret <== NOT EXECUTED =============================================================================== 00112624 : void *buffer, size_t *size, rtems_option option_set, rtems_interval timeout ) { 112624: 55 push %ebp 112625: 89 e5 mov %esp,%ebp 112627: 57 push %edi 112628: 56 push %esi 112629: 53 push %ebx 11262a: 83 ec 1c sub $0x1c,%esp 11262d: 8b 7d 0c mov 0xc(%ebp),%edi 112630: 8b 75 10 mov 0x10(%ebp),%esi 112633: 8b 5d 14 mov 0x14(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; bool wait; if ( !buffer ) 112636: 85 ff test %edi,%edi 112638: 74 6e je 1126a8 return RTEMS_INVALID_ADDRESS; if ( !size ) 11263a: 85 f6 test %esi,%esi 11263c: 74 6a je 1126a8 11263e: 51 push %ecx 11263f: 8d 45 f0 lea -0x10(%ebp),%eax 112642: 50 push %eax 112643: ff 75 08 pushl 0x8(%ebp) 112646: 68 60 5d 13 00 push $0x135d60 11264b: e8 90 45 00 00 call 116be0 <_Objects_Get> return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 112650: 83 c4 10 add $0x10,%esp 112653: 8b 55 f0 mov -0x10(%ebp),%edx 112656: 85 d2 test %edx,%edx 112658: 75 3e jne 112698 if ( _Options_Is_no_wait( option_set ) ) wait = false; else wait = true; _CORE_message_queue_Seize( 11265a: 83 ec 08 sub $0x8,%esp 11265d: ff 75 18 pushl 0x18(%ebp) 112660: 83 f3 01 xor $0x1,%ebx 112663: 83 e3 01 and $0x1,%ebx 112666: 53 push %ebx 112667: 56 push %esi 112668: 57 push %edi 112669: ff 70 08 pushl 0x8(%eax) 11266c: 83 c0 14 add $0x14,%eax 11266f: 50 push %eax 112670: e8 9b 30 00 00 call 115710 <_CORE_message_queue_Seize> buffer, size, wait, timeout ); _Thread_Enable_dispatch(); 112675: 83 c4 20 add $0x20,%esp 112678: e8 a7 4d 00 00 call 117424 <_Thread_Enable_dispatch> return _Message_queue_Translate_core_message_queue_return_code( 11267d: 83 ec 0c sub $0xc,%esp 112680: a1 fc 5a 13 00 mov 0x135afc,%eax 112685: ff 70 34 pushl 0x34(%eax) 112688: e8 a7 00 00 00 call 112734 <_Message_queue_Translate_core_message_queue_return_code> 11268d: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112690: 8d 65 f4 lea -0xc(%ebp),%esp 112693: 5b pop %ebx 112694: 5e pop %esi 112695: 5f pop %edi 112696: c9 leave 112697: c3 ret if ( !size ) return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 112698: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11269d: 8d 65 f4 lea -0xc(%ebp),%esp 1126a0: 5b pop %ebx 1126a1: 5e pop %esi 1126a2: 5f pop %edi 1126a3: c9 leave 1126a4: c3 ret 1126a5: 8d 76 00 lea 0x0(%esi),%esi size, wait, timeout ); _Thread_Enable_dispatch(); return _Message_queue_Translate_core_message_queue_return_code( 1126a8: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1126ad: 8d 65 f4 lea -0xc(%ebp),%esp 1126b0: 5b pop %ebx 1126b1: 5e pop %esi 1126b2: 5f pop %edi 1126b3: c9 leave 1126b4: c3 ret =============================================================================== 0010a0e4 : rtems_status_code rtems_message_queue_send( Objects_Id id, const void *buffer, size_t size ) { 10a0e4: 55 push %ebp 10a0e5: 89 e5 mov %esp,%ebp 10a0e7: 56 push %esi 10a0e8: 53 push %ebx 10a0e9: 83 ec 10 sub $0x10,%esp 10a0ec: 8b 75 08 mov 0x8(%ebp),%esi 10a0ef: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 10a0f2: 85 db test %ebx,%ebx 10a0f4: 74 5e je 10a154 <== NEVER TAKEN * @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, 10a0f6: 51 push %ecx 10a0f7: 8d 45 f4 lea -0xc(%ebp),%eax 10a0fa: 50 push %eax 10a0fb: 56 push %esi 10a0fc: 68 80 e9 11 00 push $0x11e980 10a101: e8 a2 19 00 00 call 10baa8 <_Objects_Get> return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 10a106: 83 c4 10 add $0x10,%esp 10a109: 8b 55 f4 mov -0xc(%ebp),%edx 10a10c: 85 d2 test %edx,%edx 10a10e: 74 0c je 10a11c 10a110: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a115: 8d 65 f8 lea -0x8(%ebp),%esp 10a118: 5b pop %ebx 10a119: 5e pop %esi 10a11a: c9 leave 10a11b: c3 ret * @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 10a11c: 6a 00 push $0x0 10a11e: 6a 00 push $0x0 10a120: 68 ff ff ff 7f push $0x7fffffff 10a125: 6a 00 push $0x0 10a127: 56 push %esi 10a128: ff 75 10 pushl 0x10(%ebp) 10a12b: 53 push %ebx 10a12c: 83 c0 14 add $0x14,%eax 10a12f: 50 push %eax 10a130: e8 93 0c 00 00 call 10adc8 <_CORE_message_queue_Submit> 10a135: 89 c3 mov %eax,%ebx MESSAGE_QUEUE_MP_HANDLER, FALSE, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 10a137: 83 c4 20 add $0x20,%esp 10a13a: e8 ad 21 00 00 call 10c2ec <_Thread_Enable_dispatch> /* * 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); 10a13f: 83 ec 0c sub $0xc,%esp 10a142: 53 push %ebx 10a143: e8 18 00 00 00 call 10a160 <_Message_queue_Translate_core_message_queue_return_code> 10a148: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a14b: 8d 65 f8 lea -0x8(%ebp),%esp 10a14e: 5b pop %ebx 10a14f: 5e pop %esi 10a150: c9 leave 10a151: c3 ret 10a152: 66 90 xchg %ax,%ax { register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 10a154: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a159: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10a15c: 5b pop %ebx <== NOT EXECUTED 10a15d: 5e pop %esi <== NOT EXECUTED 10a15e: c9 leave <== NOT EXECUTED 10a15f: c3 ret <== NOT EXECUTED =============================================================================== 00112744 : rtems_status_code rtems_message_queue_urgent( Objects_Id id, const void *buffer, size_t size ) { 112744: 55 push %ebp 112745: 89 e5 mov %esp,%ebp 112747: 56 push %esi 112748: 53 push %ebx 112749: 83 ec 10 sub $0x10,%esp 11274c: 8b 75 08 mov 0x8(%ebp),%esi 11274f: 8b 5d 0c mov 0xc(%ebp),%ebx register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 112752: 85 db test %ebx,%ebx 112754: 74 5e je 1127b4 <== NEVER TAKEN * @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, 112756: 51 push %ecx 112757: 8d 45 f4 lea -0xc(%ebp),%eax 11275a: 50 push %eax 11275b: 56 push %esi 11275c: 68 60 5d 13 00 push $0x135d60 112761: e8 7a 44 00 00 call 116be0 <_Objects_Get> return RTEMS_INVALID_ADDRESS; the_message_queue = _Message_queue_Get( id, &location ); switch ( location ) { 112766: 83 c4 10 add $0x10,%esp 112769: 8b 55 f4 mov -0xc(%ebp),%edx 11276c: 85 d2 test %edx,%edx 11276e: 74 0c je 11277c 112770: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112775: 8d 65 f8 lea -0x8(%ebp),%esp 112778: 5b pop %ebx 112779: 5e pop %esi 11277a: c9 leave 11277b: c3 ret size_t size 11277c: 6a 00 push $0x0 11277e: 6a 00 push $0x0 112780: 68 00 00 00 80 push $0x80000000 112785: 6a 00 push $0x0 112787: 56 push %esi 112788: ff 75 10 pushl 0x10(%ebp) 11278b: 53 push %ebx 11278c: 83 c0 14 add $0x14,%eax 11278f: 50 push %eax 112790: e8 a7 30 00 00 call 11583c <_CORE_message_queue_Submit> 112795: 89 c3 mov %eax,%ebx id, MESSAGE_QUEUE_MP_HANDLER, FALSE, /* sender does not block */ 0 /* no timeout */ ); _Thread_Enable_dispatch(); 112797: 83 c4 20 add $0x20,%esp 11279a: e8 85 4c 00 00 call 117424 <_Thread_Enable_dispatch> /* * 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); 11279f: 83 ec 0c sub $0xc,%esp 1127a2: 53 push %ebx 1127a3: e8 8c ff ff ff call 112734 <_Message_queue_Translate_core_message_queue_return_code> 1127a8: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1127ab: 8d 65 f8 lea -0x8(%ebp),%esp 1127ae: 5b pop %ebx 1127af: 5e pop %esi 1127b0: c9 leave 1127b1: c3 ret 1127b2: 66 90 xchg %ax,%ax { register Message_queue_Control *the_message_queue; Objects_Locations location; CORE_message_queue_Status status; if ( !buffer ) 1127b4: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1127b9: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1127bc: 5b pop %ebx <== NOT EXECUTED 1127bd: 5e pop %esi <== NOT EXECUTED 1127be: c9 leave <== NOT EXECUTED 1127bf: c3 ret <== NOT EXECUTED =============================================================================== 0010b720 : const char *rtems_object_get_api_class_name( uint32_t the_api, uint32_t the_class ) { 10b720: 55 push %ebp 10b721: 89 e5 mov %esp,%ebp 10b723: 83 ec 08 sub $0x8,%esp const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) 10b726: 83 7d 08 01 cmpl $0x1,0x8(%ebp) 10b72a: 74 2c je 10b758 api_assoc = rtems_object_api_internal_assoc; else if ( the_api == OBJECTS_CLASSIC_API ) 10b72c: 83 7d 08 02 cmpl $0x2,0x8(%ebp) 10b730: 74 0a je 10b73c 10b732: b8 90 c5 11 00 mov $0x11c590,%eax return "BAD API"; class_assoc = rtems_assoc_ptr_by_local( api_assoc, the_class ); if ( class_assoc ) return class_assoc->name; return "BAD CLASS"; } 10b737: c9 leave 10b738: c3 ret 10b739: 8d 76 00 lea 0x0(%esi),%esi 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 ) 10b73c: b8 e0 14 12 00 mov $0x1214e0,%eax 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 ); 10b741: 83 ec 08 sub $0x8,%esp 10b744: ff 75 0c pushl 0xc(%ebp) 10b747: 50 push %eax 10b748: e8 3b 47 00 00 call 10fe88 if ( class_assoc ) 10b74d: 83 c4 10 add $0x10,%esp 10b750: 85 c0 test %eax,%eax 10b752: 74 0c je 10b760 return class_assoc->name; 10b754: 8b 00 mov (%eax),%eax return "BAD CLASS"; } 10b756: c9 leave 10b757: c3 ret ) { const rtems_assoc_t *api_assoc; const rtems_assoc_t *class_assoc; if ( the_api == OBJECTS_INTERNAL_API ) 10b758: b8 c0 14 12 00 mov $0x1214c0,%eax 10b75d: eb e2 jmp 10b741 10b75f: 90 nop 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 ) 10b760: b8 98 c5 11 00 mov $0x11c598,%eax return class_assoc->name; return "BAD CLASS"; } 10b765: c9 leave 10b766: c3 ret =============================================================================== 0010b768 : }; const char *rtems_object_get_api_name( uint32_t api ) { 10b768: 55 push %ebp 10b769: 89 e5 mov %esp,%ebp 10b76b: 83 ec 10 sub $0x10,%esp const rtems_assoc_t *api_assoc; api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api ); 10b76e: ff 75 08 pushl 0x8(%ebp) 10b771: 68 60 15 12 00 push $0x121560 10b776: e8 0d 47 00 00 call 10fe88 if ( api_assoc ) 10b77b: 83 c4 10 add $0x10,%esp 10b77e: 85 c0 test %eax,%eax 10b780: 74 06 je 10b788 return api_assoc->name; 10b782: 8b 00 mov (%eax),%eax return "BAD CLASS"; } 10b784: c9 leave 10b785: c3 ret 10b786: 66 90 xchg %ax,%ax ) { const rtems_assoc_t *api_assoc; api_assoc = rtems_assoc_ptr_by_local( rtems_objects_api_assoc, api ); if ( api_assoc ) 10b788: b8 98 c5 11 00 mov $0x11c598,%eax return api_assoc->name; return "BAD CLASS"; } 10b78d: c9 leave 10b78e: c3 ret =============================================================================== 0010b7d0 : rtems_status_code rtems_object_get_class_information( uint32_t the_api, uint32_t the_class, rtems_object_api_class_information *info ) { 10b7d0: 55 push %ebp 10b7d1: 89 e5 mov %esp,%ebp 10b7d3: 56 push %esi 10b7d4: 53 push %ebx 10b7d5: 8b 75 10 mov 0x10(%ebp),%esi uint32_t i; /* * Validate parameters and look up information structure. */ if ( !info ) 10b7d8: 85 f6 test %esi,%esi 10b7da: 74 58 je 10b834 return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); 10b7dc: 83 ec 08 sub $0x8,%esp 10b7df: ff 75 0c pushl 0xc(%ebp) 10b7e2: ff 75 08 pushl 0x8(%ebp) 10b7e5: e8 22 1a 00 00 call 10d20c <_Objects_Get_information> 10b7ea: 89 c2 mov %eax,%edx if ( !obj_info ) 10b7ec: 83 c4 10 add $0x10,%esp 10b7ef: 85 c0 test %eax,%eax 10b7f1: 74 4d je 10b840 return RTEMS_INVALID_NUMBER; /* * Return information about this object class to the user. */ info->minimum_id = obj_info->minimum_id; 10b7f3: 8b 40 08 mov 0x8(%eax),%eax 10b7f6: 89 06 mov %eax,(%esi) info->maximum_id = obj_info->maximum_id; 10b7f8: 8b 42 0c mov 0xc(%edx),%eax 10b7fb: 89 46 04 mov %eax,0x4(%esi) info->auto_extend = obj_info->auto_extend; 10b7fe: 8a 42 12 mov 0x12(%edx),%al 10b801: 88 46 0c mov %al,0xc(%esi) info->maximum = obj_info->maximum; 10b804: 0f b7 42 10 movzwl 0x10(%edx),%eax 10b808: 89 46 08 mov %eax,0x8(%esi) for ( unallocated=0, i=1 ; i <= info->maximum ; i++ ) 10b80b: 85 c0 test %eax,%eax 10b80d: 74 3d je 10b84c <== NEVER TAKEN 10b80f: 8b 5a 1c mov 0x1c(%edx),%ebx 10b812: 31 c9 xor %ecx,%ecx 10b814: ba 01 00 00 00 mov $0x1,%edx 10b819: 8d 76 00 lea 0x0(%esi),%esi if ( !obj_info->local_table[i] ) unallocated++; 10b81c: 83 3c 93 01 cmpl $0x1,(%ebx,%edx,4) 10b820: 83 d1 00 adc $0x0,%ecx 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++ ) 10b823: 42 inc %edx 10b824: 39 d0 cmp %edx,%eax 10b826: 73 f4 jae 10b81c if ( !obj_info->local_table[i] ) unallocated++; info->unallocated = unallocated; 10b828: 89 4e 10 mov %ecx,0x10(%esi) 10b82b: 31 c0 xor %eax,%eax return RTEMS_SUCCESSFUL; } 10b82d: 8d 65 f8 lea -0x8(%ebp),%esp 10b830: 5b pop %ebx 10b831: 5e pop %esi 10b832: c9 leave 10b833: c3 ret uint32_t i; /* * Validate parameters and look up information structure. */ if ( !info ) 10b834: b8 09 00 00 00 mov $0x9,%eax unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 10b839: 8d 65 f8 lea -0x8(%ebp),%esp 10b83c: 5b pop %ebx 10b83d: 5e pop %esi 10b83e: c9 leave 10b83f: c3 ret */ if ( !info ) return RTEMS_INVALID_ADDRESS; obj_info = _Objects_Get_information( the_api, the_class ); if ( !obj_info ) 10b840: b8 0a 00 00 00 mov $0xa,%eax unallocated++; info->unallocated = unallocated; return RTEMS_SUCCESSFUL; } 10b845: 8d 65 f8 lea -0x8(%ebp),%esp 10b848: 5b pop %ebx 10b849: 5e pop %esi 10b84a: c9 leave 10b84b: c3 ret 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++ ) 10b84c: 31 c9 xor %ecx,%ecx <== NOT EXECUTED 10b84e: eb d8 jmp 10b828 <== NOT EXECUTED =============================================================================== 0010b04c : rtems_status_code rtems_object_get_classic_name( rtems_id id, rtems_name *name ) { 10b04c: 55 push %ebp 10b04d: 89 e5 mov %esp,%ebp 10b04f: 53 push %ebx 10b050: 83 ec 14 sub $0x14,%esp 10b053: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) 10b056: 85 db test %ebx,%ebx 10b058: 74 26 je 10b080 return RTEMS_INVALID_ADDRESS; status = _Objects_Id_to_name( id, &name_u ); 10b05a: 83 ec 08 sub $0x8,%esp 10b05d: 8d 45 f8 lea -0x8(%ebp),%eax 10b060: 50 push %eax 10b061: ff 75 08 pushl 0x8(%ebp) 10b064: e8 d3 1a 00 00 call 10cb3c <_Objects_Id_to_name> *name = name_u.name_u32; 10b069: 8b 55 f8 mov -0x8(%ebp),%edx 10b06c: 89 13 mov %edx,(%ebx) return _Status_Object_name_errors_to_status[ status ]; 10b06e: 8b 04 85 4c b5 11 00 mov 0x11b54c(,%eax,4),%eax 10b075: 83 c4 10 add $0x10,%esp } 10b078: 8b 5d fc mov -0x4(%ebp),%ebx 10b07b: c9 leave 10b07c: c3 ret 10b07d: 8d 76 00 lea 0x0(%esi),%esi ) { Objects_Name_or_id_lookup_errors status; Objects_Name name_u; if ( !name ) 10b080: b8 09 00 00 00 mov $0x9,%eax status = _Objects_Id_to_name( id, &name_u ); *name = name_u.name_u32; return _Status_Object_name_errors_to_status[ status ]; } 10b085: 8b 5d fc mov -0x4(%ebp),%ebx 10b088: c9 leave 10b089: c3 ret =============================================================================== 0010b8a8 : */ rtems_status_code rtems_object_set_name( rtems_id id, const char *name ) { 10b8a8: 55 push %ebp 10b8a9: 89 e5 mov %esp,%ebp 10b8ab: 57 push %edi 10b8ac: 56 push %esi 10b8ad: 53 push %ebx 10b8ae: 83 ec 1c sub $0x1c,%esp 10b8b1: 8b 45 08 mov 0x8(%ebp),%eax 10b8b4: 8b 7d 0c mov 0xc(%ebp),%edi Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 10b8b7: 85 ff test %edi,%edi 10b8b9: 74 65 je 10b920 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10b8bb: 85 c0 test %eax,%eax 10b8bd: 74 45 je 10b904 10b8bf: 89 c3 mov %eax,%ebx information = _Objects_Get_information_id( tmpId ); 10b8c1: 83 ec 0c sub $0xc,%esp 10b8c4: 53 push %ebx 10b8c5: e8 22 19 00 00 call 10d1ec <_Objects_Get_information_id> 10b8ca: 89 c6 mov %eax,%esi if ( !information ) 10b8cc: 83 c4 10 add $0x10,%esp 10b8cf: 85 c0 test %eax,%eax 10b8d1: 74 3d je 10b910 return RTEMS_INVALID_ID; the_object = _Objects_Get( information, tmpId, &location ); 10b8d3: 50 push %eax 10b8d4: 8d 45 f0 lea -0x10(%ebp),%eax 10b8d7: 50 push %eax 10b8d8: 53 push %ebx 10b8d9: 56 push %esi 10b8da: e8 cd 1a 00 00 call 10d3ac <_Objects_Get> switch ( location ) { 10b8df: 83 c4 10 add $0x10,%esp 10b8e2: 8b 4d f0 mov -0x10(%ebp),%ecx 10b8e5: 85 c9 test %ecx,%ecx 10b8e7: 75 27 jne 10b910 case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); 10b8e9: 52 push %edx 10b8ea: 57 push %edi 10b8eb: 50 push %eax 10b8ec: 56 push %esi 10b8ed: e8 32 1d 00 00 call 10d624 <_Objects_Set_name> _Thread_Enable_dispatch(); 10b8f2: e8 81 24 00 00 call 10dd78 <_Thread_Enable_dispatch> 10b8f7: 31 c0 xor %eax,%eax 10b8f9: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b8fc: 8d 65 f4 lea -0xc(%ebp),%esp 10b8ff: 5b pop %ebx 10b900: 5e pop %esi 10b901: 5f pop %edi 10b902: c9 leave 10b903: c3 ret Objects_Id tmpId; if ( !name ) return RTEMS_INVALID_ADDRESS; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id; 10b904: a1 5c 38 12 00 mov 0x12385c,%eax 10b909: 8b 58 08 mov 0x8(%eax),%ebx 10b90c: eb b3 jmp 10b8c1 10b90e: 66 90 xchg %ax,%ax switch ( location ) { case OBJECTS_LOCAL: _Objects_Set_name( information, the_object, name ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 10b910: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b915: 8d 65 f4 lea -0xc(%ebp),%esp 10b918: 5b pop %ebx 10b919: 5e pop %esi 10b91a: 5f pop %edi 10b91b: c9 leave 10b91c: c3 ret 10b91d: 8d 76 00 lea 0x0(%esi),%esi Objects_Information *information; Objects_Locations location; Objects_Control *the_object; Objects_Id tmpId; if ( !name ) 10b920: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10b925: eb d5 jmp 10b8fc <== NOT EXECUTED =============================================================================== 00107cbc : void rtems_panic( const char *printf_format, ... ) { 107cbc: 55 push %ebp <== NOT EXECUTED 107cbd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107cbf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107cc2: 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); 107cc5: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 107cc8: b8 00 00 00 20 mov $0x20000000,%eax <== NOT EXECUTED 107ccd: e8 42 fe ff ff call 107b14 <== NOT EXECUTED va_end(arglist); } 107cd2: c9 leave <== NOT EXECUTED 107cd3: c3 ret <== NOT EXECUTED =============================================================================== 001127c0 : uint32_t length, uint32_t buffer_size, rtems_attribute attribute_set, Objects_Id *id ) { 1127c0: 55 push %ebp 1127c1: 89 e5 mov %esp,%ebp 1127c3: 56 push %esi 1127c4: 53 push %ebx 1127c5: 8b 75 08 mov 0x8(%ebp),%esi register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 1127c8: 85 f6 test %esi,%esi 1127ca: 74 48 je 112814 return RTEMS_INVALID_NAME; if ( !starting_address ) 1127cc: 8b 5d 0c mov 0xc(%ebp),%ebx 1127cf: 85 db test %ebx,%ebx 1127d1: 74 27 je 1127fa <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( !id ) 1127d3: 8b 4d 1c mov 0x1c(%ebp),%ecx 1127d6: 85 c9 test %ecx,%ecx 1127d8: 74 20 je 1127fa <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( length == 0 || buffer_size == 0 || length < buffer_size || 1127da: 8b 55 10 mov 0x10(%ebp),%edx 1127dd: 85 d2 test %edx,%edx 1127df: 74 27 je 112808 1127e1: 8b 45 14 mov 0x14(%ebp),%eax 1127e4: 85 c0 test %eax,%eax 1127e6: 74 20 je 112808 1127e8: 8b 45 14 mov 0x14(%ebp),%eax 1127eb: 39 45 10 cmp %eax,0x10(%ebp) 1127ee: 72 18 jb 112808 1127f0: a8 03 test $0x3,%al 1127f2: 75 14 jne 112808 !_Partition_Is_buffer_size_aligned( buffer_size ) ) return RTEMS_INVALID_SIZE; if ( !_Addresses_Is_aligned( starting_address ) ) 1127f4: f6 45 0c 03 testb $0x3,0xc(%ebp) 1127f8: 74 26 je 112820 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 1127fa: b8 09 00 00 00 mov $0x9,%eax } 1127ff: 8d 65 f8 lea -0x8(%ebp),%esp 112802: 5b pop %ebx 112803: 5e pop %esi 112804: c9 leave 112805: c3 ret 112806: 66 90 xchg %ax,%ax 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 112808: b8 08 00 00 00 mov $0x8,%eax } 11280d: 8d 65 f8 lea -0x8(%ebp),%esp 112810: 5b pop %ebx 112811: 5e pop %esi 112812: c9 leave 112813: c3 ret Objects_Id *id ) { register Partition_Control *the_partition; if ( !rtems_is_name_valid( name ) ) 112814: b8 03 00 00 00 mov $0x3,%eax ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 112819: 8d 65 f8 lea -0x8(%ebp),%esp 11281c: 5b pop %ebx 11281d: 5e pop %esi 11281e: c9 leave 11281f: c3 ret /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 112820: a1 38 5a 13 00 mov 0x135a38,%eax 112825: 40 inc %eax 112826: a3 38 5a 13 00 mov %eax,0x135a38 * 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 11282b: 83 ec 0c sub $0xc,%esp 11282e: 68 40 58 13 00 push $0x135840 112833: e8 74 3e 00 00 call 1166ac <_Objects_Allocate> 112838: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { 11283a: 83 c4 10 add $0x10,%esp 11283d: 85 c0 test %eax,%eax 11283f: 74 5f je 1128a0 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_partition->starting_address = starting_address; 112841: 8b 45 0c mov 0xc(%ebp),%eax 112844: 89 43 10 mov %eax,0x10(%ebx) the_partition->length = length; 112847: 8b 45 10 mov 0x10(%ebp),%eax 11284a: 89 43 14 mov %eax,0x14(%ebx) the_partition->buffer_size = buffer_size; 11284d: 8b 45 14 mov 0x14(%ebp),%eax 112850: 89 43 18 mov %eax,0x18(%ebx) the_partition->attribute_set = attribute_set; 112853: 8b 45 18 mov 0x18(%ebp),%eax 112856: 89 43 1c mov %eax,0x1c(%ebx) the_partition->number_of_used_blocks = 0; 112859: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx) _Chain_Initialize( &the_partition->Memory, starting_address, 112860: ff 75 14 pushl 0x14(%ebp) 112863: 8b 45 10 mov 0x10(%ebp),%eax 112866: 31 d2 xor %edx,%edx 112868: f7 75 14 divl 0x14(%ebp) 11286b: 50 push %eax 11286c: ff 75 0c pushl 0xc(%ebp) 11286f: 8d 43 24 lea 0x24(%ebx),%eax 112872: 50 push %eax 112873: e8 78 2c 00 00 call 1154f0 <_Chain_Initialize> 112878: 8b 4b 08 mov 0x8(%ebx),%ecx 11287b: 0f b7 d1 movzwl %cx,%edx 11287e: a1 5c 58 13 00 mov 0x13585c,%eax 112883: 89 1c 90 mov %ebx,(%eax,%edx,4) 112886: 89 73 0c mov %esi,0xc(%ebx) &_Partition_Information, &the_partition->Object, (Objects_Name) name ); *id = the_partition->Object.id; 112889: 8b 45 1c mov 0x1c(%ebp),%eax 11288c: 89 08 mov %ecx,(%eax) name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 11288e: e8 91 4b 00 00 call 117424 <_Thread_Enable_dispatch> 112893: 31 c0 xor %eax,%eax 112895: 83 c4 10 add $0x10,%esp 112898: e9 70 ff ff ff jmp 11280d 11289d: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* prevents deletion */ the_partition = _Partition_Allocate(); if ( !the_partition ) { _Thread_Enable_dispatch(); 1128a0: e8 7f 4b 00 00 call 117424 <_Thread_Enable_dispatch> 1128a5: b8 05 00 00 00 mov $0x5,%eax 1128aa: e9 5e ff ff ff jmp 11280d =============================================================================== 001128b0 : */ rtems_status_code rtems_partition_delete( Objects_Id id ) { 1128b0: 55 push %ebp 1128b1: 89 e5 mov %esp,%ebp 1128b3: 53 push %ebx 1128b4: 83 ec 18 sub $0x18,%esp ); /** * 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. 1128b7: 8d 45 f8 lea -0x8(%ebp),%eax 1128ba: 50 push %eax 1128bb: ff 75 08 pushl 0x8(%ebp) 1128be: 68 40 58 13 00 push $0x135840 1128c3: e8 18 43 00 00 call 116be0 <_Objects_Get> 1128c8: 89 c3 mov %eax,%ebx register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 1128ca: 83 c4 10 add $0x10,%esp 1128cd: 8b 45 f8 mov -0x8(%ebp),%eax 1128d0: 85 c0 test %eax,%eax 1128d2: 74 0c je 1128e0 1128d4: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1128d9: 8b 5d fc mov -0x4(%ebp),%ebx 1128dc: c9 leave 1128dd: c3 ret 1128de: 66 90 xchg %ax,%ax the_partition = _Partition_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( the_partition->number_of_used_blocks == 0 ) { 1128e0: 8b 4b 20 mov 0x20(%ebx),%ecx 1128e3: 85 c9 test %ecx,%ecx 1128e5: 74 11 je 1128f8 #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 1128e7: e8 38 4b 00 00 call 117424 <_Thread_Enable_dispatch> 1128ec: b8 0c 00 00 00 mov $0xc,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1128f1: 8b 5d fc mov -0x4(%ebp),%ebx 1128f4: c9 leave 1128f5: c3 ret 1128f6: 66 90 xchg %ax,%ax 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 ); 1128f8: 83 ec 08 sub $0x8,%esp 1128fb: 53 push %ebx 1128fc: 68 40 58 13 00 push $0x135840 112901: e8 26 3e 00 00 call 11672c <_Objects_Close> 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. 112906: 58 pop %eax 112907: 5a pop %edx 112908: 53 push %ebx 112909: 68 40 58 13 00 push $0x135840 11290e: e8 59 41 00 00 call 116a6c <_Objects_Free> 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 112913: e8 0c 4b 00 00 call 117424 <_Thread_Enable_dispatch> 112918: 31 c0 xor %eax,%eax 11291a: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11291d: 8b 5d fc mov -0x4(%ebp),%ebx 112920: c9 leave 112921: c3 ret =============================================================================== 00112924 : rtems_status_code rtems_partition_get_buffer( Objects_Id id, void **buffer ) { 112924: 55 push %ebp 112925: 89 e5 mov %esp,%ebp 112927: 57 push %edi 112928: 56 push %esi 112929: 53 push %ebx 11292a: 83 ec 1c sub $0x1c,%esp 11292d: 8b 7d 0c mov 0xc(%ebp),%edi register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 112930: 85 ff test %edi,%edi 112932: 74 58 je 11298c <== NEVER TAKEN ); /** * 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. 112934: 52 push %edx 112935: 8d 45 f0 lea -0x10(%ebp),%eax 112938: 50 push %eax 112939: ff 75 08 pushl 0x8(%ebp) 11293c: 68 40 58 13 00 push $0x135840 112941: e8 9a 42 00 00 call 116be0 <_Objects_Get> 112946: 89 c3 mov %eax,%ebx return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 112948: 83 c4 10 add $0x10,%esp 11294b: 8b 45 f0 mov -0x10(%ebp),%eax 11294e: 85 c0 test %eax,%eax 112950: 75 2a jne 11297c #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 112952: 83 ec 0c sub $0xc,%esp 112955: 8d 43 24 lea 0x24(%ebx),%eax 112958: 50 push %eax 112959: e8 6a 2b 00 00 call 1154c8 <_Chain_Get> 11295e: 89 c6 mov %eax,%esi case OBJECTS_LOCAL: the_buffer = _Partition_Allocate_buffer( the_partition ); if ( the_buffer ) { 112960: 83 c4 10 add $0x10,%esp 112963: 85 c0 test %eax,%eax 112965: 74 35 je 11299c the_partition->number_of_used_blocks += 1; 112967: ff 43 20 incl 0x20(%ebx) _Thread_Enable_dispatch(); 11296a: e8 b5 4a 00 00 call 117424 <_Thread_Enable_dispatch> *buffer = the_buffer; 11296f: 89 37 mov %esi,(%edi) 112971: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112973: 8d 65 f4 lea -0xc(%ebp),%esp 112976: 5b pop %ebx 112977: 5e pop %esi 112978: 5f pop %edi 112979: c9 leave 11297a: c3 ret 11297b: 90 nop if ( !buffer ) return RTEMS_INVALID_ADDRESS; the_partition = _Partition_Get( id, &location ); switch ( location ) { 11297c: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112981: 8d 65 f4 lea -0xc(%ebp),%esp 112984: 5b pop %ebx 112985: 5e pop %esi 112986: 5f pop %edi 112987: c9 leave 112988: c3 ret 112989: 8d 76 00 lea 0x0(%esi),%esi { register Partition_Control *the_partition; Objects_Locations location; void *the_buffer; if ( !buffer ) 11298c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112991: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 112994: 5b pop %ebx <== NOT EXECUTED 112995: 5e pop %esi <== NOT EXECUTED 112996: 5f pop %edi <== NOT EXECUTED 112997: c9 leave <== NOT EXECUTED 112998: c3 ret <== NOT EXECUTED 112999: 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(); 11299c: e8 83 4a 00 00 call 117424 <_Thread_Enable_dispatch> 1129a1: b8 0d 00 00 00 mov $0xd,%eax 1129a6: eb d9 jmp 112981 =============================================================================== 001129cc : rtems_status_code rtems_partition_return_buffer( Objects_Id id, void *buffer ) { 1129cc: 55 push %ebp 1129cd: 89 e5 mov %esp,%ebp 1129cf: 53 push %ebx 1129d0: 83 ec 18 sub $0x18,%esp ); /** * 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. 1129d3: 8d 45 f8 lea -0x8(%ebp),%eax 1129d6: 50 push %eax 1129d7: ff 75 08 pushl 0x8(%ebp) 1129da: 68 40 58 13 00 push $0x135840 1129df: e8 fc 41 00 00 call 116be0 <_Objects_Get> 1129e4: 89 c3 mov %eax,%ebx register Partition_Control *the_partition; Objects_Locations location; the_partition = _Partition_Get( id, &location ); switch ( location ) { 1129e6: 83 c4 10 add $0x10,%esp 1129e9: 8b 45 f8 mov -0x8(%ebp),%eax 1129ec: 85 c0 test %eax,%eax 1129ee: 74 0c je 1129fc 1129f0: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1129f5: 8b 5d fc mov -0x4(%ebp),%ebx 1129f8: c9 leave 1129f9: c3 ret 1129fa: 66 90 xchg %ax,%ax * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); 1129fc: 8b 53 10 mov 0x10(%ebx),%edx 1129ff: 8b 43 14 mov 0x14(%ebx),%eax Heap_Control *the_heap, void *starting_address, size_t *size ); /** 112a02: 39 55 0c cmp %edx,0xc(%ebp) 112a05: 73 11 jae 112a18 _Partition_Free_buffer( the_partition, buffer ); the_partition->number_of_used_blocks -= 1; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 112a07: e8 18 4a 00 00 call 117424 <_Thread_Enable_dispatch> 112a0c: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112a11: 8b 5d fc mov -0x4(%ebp),%ebx 112a14: c9 leave 112a15: c3 ret 112a16: 66 90 xchg %ax,%ax 112a18: 8d 04 02 lea (%edx,%eax,1),%eax 112a1b: 39 45 0c cmp %eax,0xc(%ebp) 112a1e: 77 e7 ja 112a07 <== NEVER TAKEN Heap_Control *the_heap, size_t size ); /** * This function attempts to allocate a memory block of @a size bytes from 112a20: 8b 45 0c mov 0xc(%ebp),%eax 112a23: 29 d0 sub %edx,%eax 112a25: 31 d2 xor %edx,%edx 112a27: f7 73 18 divl 0x18(%ebx) 112a2a: 85 d2 test %edx,%edx 112a2c: 75 d9 jne 112a07 * @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( 112a2e: 83 ec 08 sub $0x8,%esp 112a31: ff 75 0c pushl 0xc(%ebp) 112a34: 8d 43 24 lea 0x24(%ebx),%eax 112a37: 50 push %eax 112a38: e8 67 2a 00 00 call 1154a4 <_Chain_Append> 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; 112a3d: ff 4b 20 decl 0x20(%ebx) _Thread_Enable_dispatch(); 112a40: e8 df 49 00 00 call 117424 <_Thread_Enable_dispatch> 112a45: 31 c0 xor %eax,%eax 112a47: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112a4a: 8b 5d fc mov -0x4(%ebp),%ebx 112a4d: c9 leave 112a4e: c3 ret =============================================================================== 00111df8 : void *internal_start, void *external_start, uint32_t length, Objects_Id *id ) { 111df8: 55 push %ebp 111df9: 89 e5 mov %esp,%ebp 111dfb: 56 push %esi 111dfc: 53 push %ebx 111dfd: 8b 75 08 mov 0x8(%ebp),%esi register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name) ) 111e00: 85 f6 test %esi,%esi 111e02: 74 20 je 111e24 return RTEMS_INVALID_NAME; if ( !id ) 111e04: 8b 45 18 mov 0x18(%ebp),%eax 111e07: 85 c0 test %eax,%eax 111e09: 74 0a je 111e15 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( internal_start ) || 111e0b: 8b 45 10 mov 0x10(%ebp),%eax 111e0e: 0b 45 0c or 0xc(%ebp),%eax 111e11: a8 03 test $0x3,%al 111e13: 74 1b je 111e30 (Objects_Name) name ); *id = the_port->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 111e15: b8 09 00 00 00 mov $0x9,%eax } 111e1a: 8d 65 f8 lea -0x8(%ebp),%esp 111e1d: 5b pop %ebx 111e1e: 5e pop %esi 111e1f: c9 leave 111e20: c3 ret 111e21: 8d 76 00 lea 0x0(%esi),%esi Objects_Id *id ) { register Dual_ported_memory_Control *the_port; if ( !rtems_is_name_valid( name) ) 111e24: b8 03 00 00 00 mov $0x3,%eax ); *id = the_port->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 111e29: 8d 65 f8 lea -0x8(%ebp),%esp 111e2c: 5b pop %ebx 111e2d: 5e pop %esi 111e2e: c9 leave 111e2f: c3 ret /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 111e30: a1 38 5a 13 00 mov 0x135a38,%eax 111e35: 40 inc %eax 111e36: a3 38 5a 13 00 mov %eax,0x135a38 #ifdef __cplusplus extern "C" { #endif /** * This routine initializes @a the_heap record to manage the 111e3b: 83 ec 0c sub $0xc,%esp 111e3e: 68 00 58 13 00 push $0x135800 111e43: e8 64 48 00 00 call 1166ac <_Objects_Allocate> 111e48: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { 111e4a: 83 c4 10 add $0x10,%esp 111e4d: 85 c0 test %eax,%eax 111e4f: 74 37 je 111e88 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_port->internal_base = internal_start; 111e51: 8b 45 0c mov 0xc(%ebp),%eax 111e54: 89 43 10 mov %eax,0x10(%ebx) the_port->external_base = external_start; 111e57: 8b 45 10 mov 0x10(%ebp),%eax 111e5a: 89 43 14 mov %eax,0x14(%ebx) the_port->length = length - 1; 111e5d: 8b 45 14 mov 0x14(%ebp),%eax 111e60: 48 dec %eax 111e61: 89 43 18 mov %eax,0x18(%ebx) 111e64: 8b 4b 08 mov 0x8(%ebx),%ecx 111e67: 0f b7 d1 movzwl %cx,%edx 111e6a: a1 1c 58 13 00 mov 0x13581c,%eax 111e6f: 89 1c 90 mov %ebx,(%eax,%edx,4) 111e72: 89 73 0c mov %esi,0xc(%ebx) &_Dual_ported_memory_Information, &the_port->Object, (Objects_Name) name ); *id = the_port->Object.id; 111e75: 8b 45 18 mov 0x18(%ebp),%eax 111e78: 89 08 mov %ecx,(%eax) _Thread_Enable_dispatch(); 111e7a: e8 a5 55 00 00 call 117424 <_Thread_Enable_dispatch> 111e7f: 31 c0 xor %eax,%eax return RTEMS_SUCCESSFUL; } 111e81: 8d 65 f8 lea -0x8(%ebp),%esp 111e84: 5b pop %ebx 111e85: 5e pop %esi 111e86: c9 leave 111e87: c3 ret _Thread_Disable_dispatch(); /* to prevent deletion */ the_port = _Dual_ported_memory_Allocate(); if ( !the_port ) { _Thread_Enable_dispatch(); 111e88: e8 97 55 00 00 call 117424 <_Thread_Enable_dispatch> 111e8d: b8 05 00 00 00 mov $0x5,%eax 111e92: eb 86 jmp 111e1a =============================================================================== 00111e94 : */ rtems_status_code rtems_port_delete( Objects_Id id ) { 111e94: 55 push %ebp 111e95: 89 e5 mov %esp,%ebp 111e97: 53 push %ebx 111e98: 83 ec 18 sub $0x18,%esp * 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 111e9b: 8d 45 f8 lea -0x8(%ebp),%eax 111e9e: 50 push %eax 111e9f: ff 75 08 pushl 0x8(%ebp) 111ea2: 68 00 58 13 00 push $0x135800 111ea7: e8 34 4d 00 00 call 116be0 <_Objects_Get> 111eac: 89 c3 mov %eax,%ebx register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111eae: 83 c4 10 add $0x10,%esp 111eb1: 8b 4d f8 mov -0x8(%ebp),%ecx 111eb4: 85 c9 test %ecx,%ecx 111eb6: 75 2c jne 111ee4 case OBJECTS_LOCAL: _Objects_Close( &_Dual_ported_memory_Information, &the_port->Object ); 111eb8: 83 ec 08 sub $0x8,%esp 111ebb: 50 push %eax 111ebc: 68 00 58 13 00 push $0x135800 111ec1: e8 66 48 00 00 call 11672c <_Objects_Close> * @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. */ 111ec6: 58 pop %eax 111ec7: 5a pop %edx 111ec8: 53 push %ebx 111ec9: 68 00 58 13 00 push $0x135800 111ece: e8 99 4b 00 00 call 116a6c <_Objects_Free> _Dual_ported_memory_Free( the_port ); _Thread_Enable_dispatch(); 111ed3: e8 4c 55 00 00 call 117424 <_Thread_Enable_dispatch> 111ed8: 31 c0 xor %eax,%eax 111eda: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111edd: 8b 5d fc mov -0x4(%ebp),%ebx 111ee0: c9 leave 111ee1: c3 ret 111ee2: 66 90 xchg %ax,%ax { register Dual_ported_memory_Control *the_port; Objects_Locations location; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111ee4: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111ee9: 8b 5d fc mov -0x4(%ebp),%ebx 111eec: c9 leave 111eed: c3 ret =============================================================================== 00111ef0 : rtems_status_code rtems_port_external_to_internal( Objects_Id id, void *external, void **internal ) { 111ef0: 55 push %ebp 111ef1: 89 e5 mov %esp,%ebp 111ef3: 53 push %ebx 111ef4: 83 ec 14 sub $0x14,%esp 111ef7: 8b 5d 10 mov 0x10(%ebp),%ebx register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !internal ) 111efa: 85 db test %ebx,%ebx 111efc: 74 4e je 111f4c <== NEVER TAKEN * 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 111efe: 51 push %ecx 111eff: 8d 45 f8 lea -0x8(%ebp),%eax 111f02: 50 push %eax 111f03: ff 75 08 pushl 0x8(%ebp) 111f06: 68 00 58 13 00 push $0x135800 111f0b: e8 d0 4c 00 00 call 116be0 <_Objects_Get> return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111f10: 83 c4 10 add $0x10,%esp 111f13: 8b 55 f8 mov -0x8(%ebp),%edx 111f16: 85 d2 test %edx,%edx 111f18: 75 1e jne 111f38 * 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 */ 111f1a: 8b 55 0c mov 0xc(%ebp),%edx 111f1d: 2b 50 14 sub 0x14(%eax),%edx case OBJECTS_LOCAL: ending = _Addresses_Subtract( external, the_port->external_base ); if ( ending > the_port->length ) 111f20: 39 50 18 cmp %edx,0x18(%eax) 111f23: 73 1f jae 111f44 *internal = external; 111f25: 8b 45 0c mov 0xc(%ebp),%eax 111f28: 89 03 mov %eax,(%ebx) else *internal = _Addresses_Add_offset( the_port->internal_base, ending ); _Thread_Enable_dispatch(); 111f2a: e8 f5 54 00 00 call 117424 <_Thread_Enable_dispatch> 111f2f: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111f31: 8b 5d fc mov -0x4(%ebp),%ebx 111f34: c9 leave 111f35: c3 ret 111f36: 66 90 xchg %ax,%ax if ( !internal ) return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111f38: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111f3d: 8b 5d fc mov -0x4(%ebp),%ebx 111f40: c9 leave 111f41: c3 ret 111f42: 66 90 xchg %ax,%ax 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, 111f44: 03 50 10 add 0x10(%eax),%edx 111f47: 89 13 mov %edx,(%ebx) 111f49: eb df jmp 111f2a 111f4b: 90 nop { register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !internal ) 111f4c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111f51: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111f54: c9 leave <== NOT EXECUTED 111f55: c3 ret <== NOT EXECUTED =============================================================================== 00111f7c : rtems_status_code rtems_port_internal_to_external( Objects_Id id, void *internal, void **external ) { 111f7c: 55 push %ebp 111f7d: 89 e5 mov %esp,%ebp 111f7f: 53 push %ebx 111f80: 83 ec 14 sub $0x14,%esp 111f83: 8b 5d 10 mov 0x10(%ebp),%ebx register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !external ) 111f86: 85 db test %ebx,%ebx 111f88: 74 4e je 111fd8 <== NEVER TAKEN * 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 111f8a: 51 push %ecx 111f8b: 8d 45 f8 lea -0x8(%ebp),%eax 111f8e: 50 push %eax 111f8f: ff 75 08 pushl 0x8(%ebp) 111f92: 68 00 58 13 00 push $0x135800 111f97: e8 44 4c 00 00 call 116be0 <_Objects_Get> return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111f9c: 83 c4 10 add $0x10,%esp 111f9f: 8b 55 f8 mov -0x8(%ebp),%edx 111fa2: 85 d2 test %edx,%edx 111fa4: 75 1e jne 111fc4 * 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 */ 111fa6: 8b 55 0c mov 0xc(%ebp),%edx 111fa9: 2b 50 10 sub 0x10(%eax),%edx case OBJECTS_LOCAL: ending = _Addresses_Subtract( internal, the_port->internal_base ); if ( ending > the_port->length ) 111fac: 39 50 18 cmp %edx,0x18(%eax) 111faf: 73 1f jae 111fd0 *external = internal; 111fb1: 8b 45 0c mov 0xc(%ebp),%eax 111fb4: 89 03 mov %eax,(%ebx) else *external = _Addresses_Add_offset( the_port->external_base, ending ); _Thread_Enable_dispatch(); 111fb6: e8 69 54 00 00 call 117424 <_Thread_Enable_dispatch> 111fbb: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111fbd: 8b 5d fc mov -0x4(%ebp),%ebx 111fc0: c9 leave 111fc1: c3 ret 111fc2: 66 90 xchg %ax,%ax if ( !external ) return RTEMS_INVALID_ADDRESS; the_port = _Dual_ported_memory_Get( id, &location ); switch ( location ) { 111fc4: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111fc9: 8b 5d fc mov -0x4(%ebp),%ebx 111fcc: c9 leave 111fcd: c3 ret 111fce: 66 90 xchg %ax,%ax 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, 111fd0: 03 50 14 add 0x14(%eax),%edx 111fd3: 89 13 mov %edx,(%ebx) 111fd5: eb df jmp 111fb6 111fd7: 90 nop { register Dual_ported_memory_Control *the_port; Objects_Locations location; uint32_t ending; if ( !external ) 111fd8: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 111fdd: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 111fe0: c9 leave <== NOT EXECUTED 111fe1: c3 ret <== NOT EXECUTED =============================================================================== 00112a50 : */ rtems_status_code rtems_rate_monotonic_cancel( Objects_Id id ) { 112a50: 55 push %ebp 112a51: 89 e5 mov %esp,%ebp 112a53: 53 push %ebx 112a54: 83 ec 18 sub $0x18,%esp /** * 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 112a57: 8d 45 f8 lea -0x8(%ebp),%eax 112a5a: 50 push %eax 112a5b: ff 75 08 pushl 0x8(%ebp) 112a5e: 68 80 58 13 00 push $0x135880 112a63: e8 78 41 00 00 call 116be0 <_Objects_Get> 112a68: 89 c3 mov %eax,%ebx Rate_monotonic_Control *the_period; Objects_Locations location; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 112a6a: 83 c4 10 add $0x10,%esp 112a6d: 8b 45 f8 mov -0x8(%ebp),%eax 112a70: 85 c0 test %eax,%eax 112a72: 74 0c je 112a80 112a74: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112a79: 8b 5d fc mov -0x4(%ebp),%ebx 112a7c: c9 leave 112a7d: c3 ret 112a7e: 66 90 xchg %ax,%ax the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 112a80: 8b 43 50 mov 0x50(%ebx),%eax 112a83: 3b 05 fc 5a 13 00 cmp 0x135afc,%eax 112a89: 74 11 je 112a9c _Thread_Enable_dispatch(); 112a8b: e8 94 49 00 00 call 117424 <_Thread_Enable_dispatch> 112a90: b8 17 00 00 00 mov $0x17,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 112a95: 8b 5d fc mov -0x4(%ebp),%ebx 112a98: c9 leave 112a99: c3 ret 112a9a: 66 90 xchg %ax,%ax 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 ); 112a9c: 83 ec 0c sub $0xc,%esp 112a9f: 8d 43 10 lea 0x10(%ebx),%eax 112aa2: 50 push %eax 112aa3: e8 74 5d 00 00 call 11881c <_Watchdog_Remove> the_period->state = RATE_MONOTONIC_INACTIVE; 112aa8: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) _Thread_Enable_dispatch(); 112aaf: e8 70 49 00 00 call 117424 <_Thread_Enable_dispatch> 112ab4: 31 c0 xor %eax,%eax 112ab6: 83 c4 10 add $0x10,%esp 112ab9: eb be jmp 112a79 =============================================================================== 0010afdc : rtems_status_code rtems_rate_monotonic_create( rtems_name name, Objects_Id *id ) { 10afdc: 55 push %ebp 10afdd: 89 e5 mov %esp,%ebp 10afdf: 57 push %edi 10afe0: 56 push %esi 10afe1: 53 push %ebx 10afe2: 83 ec 0c sub $0xc,%esp 10afe5: 8b 75 08 mov 0x8(%ebp),%esi Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 10afe8: 85 f6 test %esi,%esi 10afea: 0f 84 a8 00 00 00 je 10b098 return RTEMS_INVALID_NAME; if ( !id ) 10aff0: 8b 45 0c mov 0xc(%ebp),%eax 10aff3: 85 c0 test %eax,%eax 10aff5: 0f 84 c1 00 00 00 je 10b0bc <== NEVER TAKEN /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10affb: a1 78 27 12 00 mov 0x122778,%eax 10b000: 40 inc %eax 10b001: a3 78 27 12 00 mov %eax,0x122778 #ifdef __cplusplus extern "C" { #endif /** 10b006: 83 ec 0c sub $0xc,%esp 10b009: 68 80 26 12 00 push $0x122680 10b00e: e8 d9 1d 00 00 call 10cdec <_Objects_Allocate> 10b013: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { 10b015: 83 c4 10 add $0x10,%esp 10b018: 85 c0 test %eax,%eax 10b01a: 0f 84 88 00 00 00 je 10b0a8 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_period->owner = _Thread_Executing; 10b020: a1 3c 28 12 00 mov 0x12283c,%eax 10b025: 89 43 50 mov %eax,0x50(%ebx) the_period->state = RATE_MONOTONIC_INACTIVE; 10b028: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) * 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. * 10b02f: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) * @param[in] the_heap is the heap to operate upon 10b036: c7 43 2c 00 00 00 00 movl $0x0,0x2c(%ebx) * @param[in] starting_address is the starting address of the memory for 10b03d: c7 43 30 00 00 00 00 movl $0x0,0x30(%ebx) * the heap 10b044: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) _Watchdog_Initialize( &the_period->Timer, NULL, 0, NULL ); _Rate_monotonic_Reset_statistics( the_period ); 10b04b: 8d 7b 54 lea 0x54(%ebx),%edi 10b04e: b9 38 00 00 00 mov $0x38,%ecx 10b053: 31 c0 xor %eax,%eax 10b055: f3 aa rep stos %al,%es:(%edi) 10b057: c7 43 5c ff ff ff 7f movl $0x7fffffff,0x5c(%ebx) 10b05e: c7 43 60 ff ff ff 7f movl $0x7fffffff,0x60(%ebx) 10b065: c7 43 74 ff ff ff 7f movl $0x7fffffff,0x74(%ebx) 10b06c: c7 43 78 ff ff ff 7f movl $0x7fffffff,0x78(%ebx) 10b073: 8b 4b 08 mov 0x8(%ebx),%ecx 10b076: 0f b7 d1 movzwl %cx,%edx 10b079: a1 9c 26 12 00 mov 0x12269c,%eax 10b07e: 89 1c 90 mov %ebx,(%eax,%edx,4) 10b081: 89 73 0c mov %esi,0xc(%ebx) &_Rate_monotonic_Information, &the_period->Object, (Objects_Name) name ); *id = the_period->Object.id; 10b084: 8b 45 0c mov 0xc(%ebp),%eax 10b087: 89 08 mov %ecx,(%eax) _Thread_Enable_dispatch(); 10b089: e8 96 2b 00 00 call 10dc24 <_Thread_Enable_dispatch> 10b08e: 31 c0 xor %eax,%eax return RTEMS_SUCCESSFUL; } 10b090: 8d 65 f4 lea -0xc(%ebp),%esp 10b093: 5b pop %ebx 10b094: 5e pop %esi 10b095: 5f pop %edi 10b096: c9 leave 10b097: c3 ret Objects_Id *id ) { Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) 10b098: b8 03 00 00 00 mov $0x3,%eax ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b09d: 8d 65 f4 lea -0xc(%ebp),%esp 10b0a0: 5b pop %ebx 10b0a1: 5e pop %esi 10b0a2: 5f pop %edi 10b0a3: c9 leave 10b0a4: c3 ret 10b0a5: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* to prevent deletion */ the_period = _Rate_monotonic_Allocate(); if ( !the_period ) { _Thread_Enable_dispatch(); 10b0a8: e8 77 2b 00 00 call 10dc24 <_Thread_Enable_dispatch> 10b0ad: b8 05 00 00 00 mov $0x5,%eax ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b0b2: 8d 65 f4 lea -0xc(%ebp),%esp 10b0b5: 5b pop %ebx 10b0b6: 5e pop %esi 10b0b7: 5f pop %edi 10b0b8: c9 leave 10b0b9: c3 ret 10b0ba: 66 90 xchg %ax,%ax Rate_monotonic_Control *the_period; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 10b0bc: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED ); *id = the_period->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b0c1: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10b0c4: 5b pop %ebx <== NOT EXECUTED 10b0c5: 5e pop %esi <== NOT EXECUTED 10b0c6: 5f pop %edi <== NOT EXECUTED 10b0c7: c9 leave <== NOT EXECUTED 10b0c8: c3 ret <== NOT EXECUTED =============================================================================== 00110878 : rtems_status_code rtems_rate_monotonic_get_statistics( Objects_Id id, rtems_rate_monotonic_period_statistics *statistics ) { 110878: 55 push %ebp 110879: 89 e5 mov %esp,%ebp 11087b: 57 push %edi 11087c: 56 push %esi 11087d: 83 ec 20 sub $0x20,%esp 110880: 8b 7d 0c mov 0xc(%ebp),%edi Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 110883: 85 ff test %edi,%edi 110885: 74 41 je 1108c8 <== NEVER TAKEN /** * 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 110887: 51 push %ecx 110888: 8d 45 f4 lea -0xc(%ebp),%eax 11088b: 50 push %eax 11088c: ff 75 08 pushl 0x8(%ebp) 11088f: 68 80 26 12 00 push $0x122680 110894: e8 47 cb ff ff call 10d3e0 <_Objects_Get> return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 110899: 83 c4 10 add $0x10,%esp 11089c: 8b 55 f4 mov -0xc(%ebp),%edx 11089f: 85 d2 test %edx,%edx 1108a1: 74 0d je 1108b0 1108a3: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1108a8: 8d 65 f8 lea -0x8(%ebp),%esp 1108ab: 5e pop %esi 1108ac: 5f pop %edi 1108ad: c9 leave 1108ae: c3 ret 1108af: 90 nop the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: *statistics = the_period->Statistics; 1108b0: 8d 70 54 lea 0x54(%eax),%esi 1108b3: b9 0e 00 00 00 mov $0xe,%ecx 1108b8: f3 a5 rep movsl %ds:(%esi),%es:(%edi) _Thread_Enable_dispatch(); 1108ba: e8 65 d3 ff ff call 10dc24 <_Thread_Enable_dispatch> 1108bf: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1108c1: 8d 65 f8 lea -0x8(%ebp),%esp 1108c4: 5e pop %esi 1108c5: 5f pop %edi 1108c6: c9 leave 1108c7: c3 ret ) { Objects_Locations location; Rate_monotonic_Control *the_period; if ( !statistics ) 1108c8: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1108cd: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 1108d0: 5e pop %esi <== NOT EXECUTED 1108d1: 5f pop %edi <== NOT EXECUTED 1108d2: c9 leave <== NOT EXECUTED 1108d3: c3 ret <== NOT EXECUTED =============================================================================== 001108d4 : rtems_status_code rtems_rate_monotonic_get_status( Objects_Id id, rtems_rate_monotonic_period_status *status ) { 1108d4: 55 push %ebp 1108d5: 89 e5 mov %esp,%ebp 1108d7: 57 push %edi 1108d8: 56 push %esi 1108d9: 53 push %ebx 1108da: 83 ec 1c sub $0x1c,%esp 1108dd: 8b 75 0c mov 0xc(%ebp),%esi Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 1108e0: 85 f6 test %esi,%esi 1108e2: 74 70 je 110954 <== NEVER TAKEN 1108e4: 52 push %edx 1108e5: 8d 45 f0 lea -0x10(%ebp),%eax 1108e8: 50 push %eax 1108e9: ff 75 08 pushl 0x8(%ebp) 1108ec: 68 80 26 12 00 push $0x122680 1108f1: e8 ea ca ff ff call 10d3e0 <_Objects_Get> 1108f6: 89 c7 mov %eax,%edi return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 1108f8: 83 c4 10 add $0x10,%esp 1108fb: 8b 45 f0 mov -0x10(%ebp),%eax 1108fe: 85 c0 test %eax,%eax 110900: 75 42 jne 110944 case OBJECTS_LOCAL: status->owner = ((the_period->owner) ? the_period->owner->Object.id : 0); 110902: 8b 47 50 mov 0x50(%edi),%eax 110905: 85 c0 test %eax,%eax 110907: 74 03 je 11090c <== NEVER TAKEN 110909: 8b 40 08 mov 0x8(%eax),%eax 11090c: 89 06 mov %eax,(%esi) status->state = the_period->state; 11090e: 8b 47 38 mov 0x38(%edi),%eax 110911: 89 46 04 mov %eax,0x4(%esi) if ( status->state == RATE_MONOTONIC_INACTIVE ) { 110914: 85 c0 test %eax,%eax 110916: 75 4c jne 110964 #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS status->since_last_period.tv_sec = 0; 110918: c7 46 08 00 00 00 00 movl $0x0,0x8(%esi) status->since_last_period.tv_nsec = 0; 11091f: c7 46 0c 00 00 00 00 movl $0x0,0xc(%esi) #else status->since_last_period = 0; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS status->executed_since_last_period.tv_sec = 0; 110926: c7 46 10 00 00 00 00 movl $0x0,0x10(%esi) status->executed_since_last_period.tv_nsec = 0; 11092d: c7 46 14 00 00 00 00 movl $0x0,0x14(%esi) the_period->owner->cpu_time_used - the_period->owner_executed_at_period; #endif } _Thread_Enable_dispatch(); 110934: e8 eb d2 ff ff call 10dc24 <_Thread_Enable_dispatch> 110939: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11093b: 8d 65 f4 lea -0xc(%ebp),%esp 11093e: 5b pop %ebx 11093f: 5e pop %esi 110940: 5f pop %edi 110941: c9 leave 110942: c3 ret 110943: 90 nop if ( !status ) return RTEMS_INVALID_ADDRESS; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 110944: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110949: 8d 65 f4 lea -0xc(%ebp),%esp 11094c: 5b pop %ebx 11094d: 5e pop %esi 11094e: 5f pop %edi 11094f: c9 leave 110950: c3 ret 110951: 8d 76 00 lea 0x0(%esi),%esi ) { Objects_Locations location; Rate_monotonic_Control *the_period; if ( !status ) 110954: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 110959: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 11095c: 5b pop %ebx <== NOT EXECUTED 11095d: 5e pop %esi <== NOT EXECUTED 11095e: 5f pop %edi <== NOT EXECUTED 11095f: c9 leave <== NOT EXECUTED 110960: c3 ret <== NOT EXECUTED 110961: 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 ); 110964: 83 ec 0c sub $0xc,%esp 110967: 8d 5d e8 lea -0x18(%ebp),%ebx 11096a: 53 push %ebx 11096b: e8 04 c1 ff ff call 10ca74 <_TOD_Get_uptime> #endif #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS _Timespec_Subtract( 110970: 83 c4 0c add $0xc,%esp 110973: 8d 46 08 lea 0x8(%esi),%eax 110976: 50 push %eax 110977: 53 push %ebx 110978: 8d 47 44 lea 0x44(%edi),%eax 11097b: 50 push %eax 11097c: e8 cf e0 ff ff call 10ea50 <_Timespec_Subtract> status->since_last_period = _Watchdog_Ticks_since_boot - the_period->time_at_period; #endif #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS _Timespec_Subtract( 110981: 83 c4 0c add $0xc,%esp 110984: 8d 46 10 lea 0x10(%esi),%eax 110987: 50 push %eax 110988: 53 push %ebx 110989: 68 44 28 12 00 push $0x122844 11098e: e8 bd e0 ff ff call 10ea50 <_Timespec_Subtract> 110993: 83 c4 10 add $0x10,%esp 110996: eb 9c jmp 110934 =============================================================================== 0010b2b4 : rtems_status_code rtems_rate_monotonic_period( Objects_Id id, rtems_interval length ) { 10b2b4: 55 push %ebp 10b2b5: 89 e5 mov %esp,%ebp 10b2b7: 57 push %edi 10b2b8: 56 push %esi 10b2b9: 53 push %ebx 10b2ba: 83 ec 20 sub $0x20,%esp 10b2bd: 8b 75 08 mov 0x8(%ebp),%esi /** * 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 10b2c0: 8d 45 f0 lea -0x10(%ebp),%eax 10b2c3: 50 push %eax 10b2c4: 56 push %esi 10b2c5: 68 80 26 12 00 push $0x122680 10b2ca: e8 11 21 00 00 call 10d3e0 <_Objects_Get> 10b2cf: 89 c3 mov %eax,%ebx rtems_rate_monotonic_period_states local_state; ISR_Level level; the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { 10b2d1: 83 c4 10 add $0x10,%esp 10b2d4: 8b 45 f0 mov -0x10(%ebp),%eax 10b2d7: 85 c0 test %eax,%eax 10b2d9: 74 11 je 10b2ec the_period->state = RATE_MONOTONIC_ACTIVE; the_period->next_length = length; _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); return RTEMS_TIMEOUT; 10b2db: bb 04 00 00 00 mov $0x4,%ebx case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b2e0: 89 d8 mov %ebx,%eax 10b2e2: 8d 65 f4 lea -0xc(%ebp),%esp 10b2e5: 5b pop %ebx 10b2e6: 5e pop %esi 10b2e7: 5f pop %edi 10b2e8: c9 leave 10b2e9: c3 ret 10b2ea: 66 90 xchg %ax,%ax the_period = _Rate_monotonic_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Thread_Is_executing( the_period->owner ) ) { 10b2ec: 8b 43 50 mov 0x50(%ebx),%eax 10b2ef: 3b 05 3c 28 12 00 cmp 0x12283c,%eax 10b2f5: 74 15 je 10b30c _Thread_Enable_dispatch(); 10b2f7: e8 28 29 00 00 call 10dc24 <_Thread_Enable_dispatch> 10b2fc: bb 17 00 00 00 mov $0x17,%ebx case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b301: 89 d8 mov %ebx,%eax 10b303: 8d 65 f4 lea -0xc(%ebp),%esp 10b306: 5b pop %ebx 10b307: 5e pop %esi 10b308: 5f pop %edi 10b309: c9 leave 10b30a: c3 ret 10b30b: 90 nop if ( !_Thread_Is_executing( the_period->owner ) ) { _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { 10b30c: 8b 45 0c mov 0xc(%ebp),%eax 10b30f: 85 c0 test %eax,%eax 10b311: 0f 84 c1 00 00 00 je 10b3d8 } _Thread_Enable_dispatch(); return( return_value ); } _ISR_Disable( level ); 10b317: 9c pushf 10b318: fa cli 10b319: 5f pop %edi switch ( the_period->state ) { 10b31a: 8b 43 38 mov 0x38(%ebx),%eax 10b31d: 83 f8 02 cmp $0x2,%eax 10b320: 74 62 je 10b384 10b322: 83 f8 04 cmp $0x4,%eax 10b325: 0f 84 c5 00 00 00 je 10b3f0 <== NEVER TAKEN 10b32b: 85 c0 test %eax,%eax 10b32d: 75 ac jne 10b2db <== NEVER TAKEN case RATE_MONOTONIC_INACTIVE: { _ISR_Enable( level ); 10b32f: 57 push %edi 10b330: 9d popf /* * Baseline statistics information for the beginning of a period. */ _Rate_monotonic_Initiate_statistics( the_period ); 10b331: 83 ec 0c sub $0xc,%esp 10b334: 53 push %ebx 10b335: e8 b6 fd ff ff call 10b0f0 <_Rate_monotonic_Initiate_statistics> the_period->state = RATE_MONOTONIC_ACTIVE; 10b33a: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) * 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. * 10b341: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) * @param[in] the_heap is the heap to operate upon 10b348: c7 43 2c 24 b7 10 00 movl $0x10b724,0x2c(%ebx) * @param[in] starting_address is the starting address of the memory for 10b34f: 89 73 30 mov %esi,0x30(%ebx) * the heap 10b352: c7 43 34 00 00 00 00 movl $0x0,0x34(%ebx) _Rate_monotonic_Timeout, id, NULL ); the_period->next_length = length; 10b359: 8b 45 0c mov 0xc(%ebp),%eax 10b35c: 89 43 4c mov %eax,0x4c(%ebx) * @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, 10b35f: 89 43 1c mov %eax,0x1c(%ebx) void *starting_address, size_t *size 10b362: 5f pop %edi 10b363: 58 pop %eax 10b364: 8d 43 10 lea 0x10(%ebx),%eax 10b367: 50 push %eax 10b368: 68 5c 28 12 00 push $0x12285c 10b36d: e8 86 39 00 00 call 10ecf8 <_Watchdog_Insert> _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10b372: e8 ad 28 00 00 call 10dc24 <_Thread_Enable_dispatch> 10b377: 31 db xor %ebx,%ebx 10b379: 83 c4 10 add $0x10,%esp 10b37c: e9 5f ff ff ff jmp 10b2e0 10b381: 8d 76 00 lea 0x0(%esi),%esi case RATE_MONOTONIC_ACTIVE: /* * Update statistics from the concluding period. */ _Rate_monotonic_Update_statistics( the_period ); 10b384: 83 ec 0c sub $0xc,%esp 10b387: 53 push %ebx 10b388: e8 d3 fd ff ff call 10b160 <_Rate_monotonic_Update_statistics> /* * 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; 10b38d: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) the_period->next_length = length; 10b394: 8b 45 0c mov 0xc(%ebp),%eax 10b397: 89 43 4c mov %eax,0x4c(%ebx) _ISR_Enable( level ); 10b39a: 57 push %edi 10b39b: 9d popf _Thread_Executing->Wait.id = the_period->Object.id; 10b39c: 8b 15 3c 28 12 00 mov 0x12283c,%edx 10b3a2: 8b 43 08 mov 0x8(%ebx),%eax 10b3a5: 89 42 20 mov %eax,0x20(%edx) _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); 10b3a8: 59 pop %ecx 10b3a9: 5e pop %esi 10b3aa: 68 00 40 00 00 push $0x4000 10b3af: 52 push %edx 10b3b0: e8 4f 31 00 00 call 10e504 <_Thread_Set_state> /* * Did the watchdog timer expire while we were actually blocking * on it? */ _ISR_Disable( level ); 10b3b5: 9c pushf 10b3b6: fa cli 10b3b7: 58 pop %eax local_state = the_period->state; 10b3b8: 8b 53 38 mov 0x38(%ebx),%edx the_period->state = RATE_MONOTONIC_ACTIVE; 10b3bb: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) _ISR_Enable( level ); 10b3c2: 50 push %eax 10b3c3: 9d popf /* * 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 ) 10b3c4: 83 c4 10 add $0x10,%esp 10b3c7: 83 fa 03 cmp $0x3,%edx 10b3ca: 74 71 je 10b43d <== NEVER TAKEN _Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD ); _Thread_Enable_dispatch(); 10b3cc: e8 53 28 00 00 call 10dc24 <_Thread_Enable_dispatch> 10b3d1: 31 db xor %ebx,%ebx 10b3d3: e9 08 ff ff ff jmp 10b2e0 _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { switch ( the_period->state ) { 10b3d8: 8b 43 38 mov 0x38(%ebx),%eax 10b3db: 85 c0 test %eax,%eax 10b3dd: 75 51 jne 10b430 <== NEVER TAKEN 10b3df: bb 0b 00 00 00 mov $0xb,%ebx case RATE_MONOTONIC_ACTIVE: default: /* unreached -- only to remove warnings */ return_value = RTEMS_SUCCESSFUL; break; } _Thread_Enable_dispatch(); 10b3e4: e8 3b 28 00 00 call 10dc24 <_Thread_Enable_dispatch> 10b3e9: e9 f2 fe ff ff jmp 10b2e0 10b3ee: 66 90 xchg %ax,%ax case RATE_MONOTONIC_EXPIRED: /* * Update statistics from the concluding period */ _Rate_monotonic_Update_statistics( the_period ); 10b3f0: 83 ec 0c sub $0xc,%esp 10b3f3: 53 push %ebx 10b3f4: e8 67 fd ff ff call 10b160 <_Rate_monotonic_Update_statistics> _ISR_Enable( level ); 10b3f9: 57 push %edi 10b3fa: 9d popf the_period->state = RATE_MONOTONIC_ACTIVE; 10b3fb: c7 43 38 02 00 00 00 movl $0x2,0x38(%ebx) the_period->next_length = length; 10b402: 8b 45 0c mov 0xc(%ebp),%eax 10b405: 89 43 4c mov %eax,0x4c(%ebx) * @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, 10b408: 89 43 1c mov %eax,0x1c(%ebx) void *starting_address, size_t *size 10b40b: 58 pop %eax 10b40c: 5a pop %edx 10b40d: 8d 43 10 lea 0x10(%ebx),%eax 10b410: 50 push %eax 10b411: 68 5c 28 12 00 push $0x12285c 10b416: e8 dd 38 00 00 call 10ecf8 <_Watchdog_Insert> _Watchdog_Insert_ticks( &the_period->Timer, length ); _Thread_Enable_dispatch(); 10b41b: e8 04 28 00 00 call 10dc24 <_Thread_Enable_dispatch> 10b420: bb 06 00 00 00 mov $0x6,%ebx 10b425: 83 c4 10 add $0x10,%esp 10b428: e9 b3 fe ff ff jmp 10b2e0 10b42d: 8d 76 00 lea 0x0(%esi),%esi _Thread_Enable_dispatch(); return RTEMS_NOT_OWNER_OF_RESOURCE; } if ( length == RTEMS_PERIOD_STATUS ) { switch ( the_period->state ) { 10b430: 83 e8 03 sub $0x3,%eax 10b433: 83 f8 02 cmp $0x2,%eax 10b436: 19 db sbb %ebx,%ebx 10b438: 83 e3 06 and $0x6,%ebx 10b43b: eb a7 jmp 10b3e4 /* * 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 ); 10b43d: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10b440: 68 00 40 00 00 push $0x4000 <== NOT EXECUTED 10b445: ff 35 3c 28 12 00 pushl 0x12283c <== NOT EXECUTED 10b44b: e8 2c 24 00 00 call 10d87c <_Thread_Clear_state> <== NOT EXECUTED 10b450: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10b453: e9 74 ff ff ff jmp 10b3cc <== NOT EXECUTED =============================================================================== 0010b458 : */ void rtems_rate_monotonic_report_statistics_with_plugin( void *context, rtems_printk_plugin_t print ) { 10b458: 55 push %ebp 10b459: 89 e5 mov %esp,%ebp 10b45b: 57 push %edi 10b45c: 56 push %esi 10b45d: 53 push %ebx 10b45e: 81 ec 9c 00 00 00 sub $0x9c,%esp 10b464: 8b 7d 0c mov 0xc(%ebp),%edi rtems_id id; rtems_rate_monotonic_period_statistics the_stats; rtems_rate_monotonic_period_status the_status; char name[5]; if ( !print ) 10b467: 85 ff test %edi,%edi 10b469: 0f 84 c9 00 00 00 je 10b538 <== NEVER TAKEN return; (*print)( context, "Period information by period\n" ); 10b46f: 83 ec 08 sub $0x8,%esp 10b472: 68 70 bb 11 00 push $0x11bb70 10b477: ff 75 08 pushl 0x8(%ebp) 10b47a: ff d7 call *%edi #if defined(RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS) (*print)( context, "--- CPU times are in seconds ---\n" ); 10b47c: 5e pop %esi 10b47d: 58 pop %eax 10b47e: 68 a8 bb 11 00 push $0x11bba8 10b483: ff 75 08 pushl 0x8(%ebp) 10b486: ff d7 call *%edi #endif #if defined(RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS) (*print)( context, "--- Wall times are in seconds ---\n" ); 10b488: 59 pop %ecx 10b489: 5b pop %ebx 10b48a: 68 cc bb 11 00 push $0x11bbcc 10b48f: ff 75 08 pushl 0x8(%ebp) 10b492: ff d7 call *%edi Be sure to test the various cases. (*print)( context,"\ 1234567890123456789012345678901234567890123456789012345678901234567890123456789\ \n"); */ (*print)( context, " ID OWNER COUNT MISSED " 10b494: 58 pop %eax 10b495: 5a pop %edx 10b496: 68 f0 bb 11 00 push $0x11bbf0 10b49b: ff 75 08 pushl 0x8(%ebp) 10b49e: ff d7 call *%edi #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS " " #endif " WALL TIME\n" ); (*print)( context, " " 10b4a0: 5b pop %ebx 10b4a1: 5e pop %esi 10b4a2: 68 3c bc 11 00 push $0x11bc3c 10b4a7: ff 75 08 pushl 0x8(%ebp) 10b4aa: ff d7 call *%edi /* * 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 ; 10b4ac: 8b 35 88 26 12 00 mov 0x122688,%esi id <= _Rate_monotonic_Information.maximum_id ; 10b4b2: 83 c4 10 add $0x10,%esp 10b4b5: 3b 35 8c 26 12 00 cmp 0x12268c,%esi 10b4bb: 76 0c jbe 10b4c9 <== ALWAYS TAKEN 10b4bd: eb 79 jmp 10b538 <== NOT EXECUTED 10b4bf: 90 nop <== NOT EXECUTED id++ ) { 10b4c0: 46 inc %esi /* * 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 ; 10b4c1: 39 35 8c 26 12 00 cmp %esi,0x12268c 10b4c7: 72 6f jb 10b538 id++ ) { status = rtems_rate_monotonic_get_statistics( id, &the_stats ); 10b4c9: 83 ec 08 sub $0x8,%esp 10b4cc: 8d 45 90 lea -0x70(%ebp),%eax 10b4cf: 50 push %eax 10b4d0: 56 push %esi 10b4d1: e8 a2 53 00 00 call 110878 if ( status != RTEMS_SUCCESSFUL ) 10b4d6: 83 c4 10 add $0x10,%esp 10b4d9: 85 c0 test %eax,%eax 10b4db: 75 e3 jne 10b4c0 continue; /* If the above passed, so should this but check it anyway */ status = rtems_rate_monotonic_get_status( id, &the_status ); 10b4dd: 83 ec 08 sub $0x8,%esp 10b4e0: 8d 55 c8 lea -0x38(%ebp),%edx 10b4e3: 52 push %edx 10b4e4: 56 push %esi 10b4e5: e8 ea 53 00 00 call 1108d4 #if defined(RTEMS_DEBUG) if ( status != RTEMS_SUCCESSFUL ) continue; #endif name[ 0 ] = '\0'; 10b4ea: c6 45 eb 00 movb $0x0,-0x15(%ebp) if ( the_status.owner ) { 10b4ee: 8b 45 c8 mov -0x38(%ebp),%eax 10b4f1: 83 c4 10 add $0x10,%esp 10b4f4: 85 c0 test %eax,%eax 10b4f6: 0f 85 54 01 00 00 jne 10b650 <== ALWAYS TAKEN 10b4fc: 8d 5d eb lea -0x15(%ebp),%ebx <== NOT EXECUTED /* * Print part of report line that is not dependent on granularity */ (*print)( context, 10b4ff: 83 ec 08 sub $0x8,%esp 10b502: ff 75 94 pushl -0x6c(%ebp) 10b505: ff 75 90 pushl -0x70(%ebp) 10b508: 53 push %ebx 10b509: 56 push %esi 10b50a: 68 8e bb 11 00 push $0x11bb8e 10b50f: ff 75 08 pushl 0x8(%ebp) 10b512: ff d7 call *%edi /* * If the count is zero, don't print statistics */ if (the_stats.count == 0) { 10b514: 8b 45 90 mov -0x70(%ebp),%eax 10b517: 83 c4 20 add $0x20,%esp 10b51a: 85 c0 test %eax,%eax 10b51c: 75 22 jne 10b540 (*print)( context, "\n" ); 10b51e: 83 ec 08 sub $0x8,%esp 10b521: 68 f9 a0 11 00 push $0x11a0f9 10b526: ff 75 08 pushl 0x8(%ebp) 10b529: ff d7 call *%edi 10b52b: 83 c4 10 add $0x10,%esp * 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++ ) { 10b52e: 46 inc %esi /* * 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 ; 10b52f: 39 35 8c 26 12 00 cmp %esi,0x12268c 10b535: 73 92 jae 10b4c9 <== ALWAYS TAKEN 10b537: 90 nop the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall ); #endif } } } 10b538: 8d 65 f4 lea -0xc(%ebp),%esp 10b53b: 5b pop %ebx 10b53c: 5e pop %esi 10b53d: 5f pop %edi 10b53e: c9 leave 10b53f: c3 ret */ { #ifdef RTEMS_ENABLE_NANOSECOND_CPU_USAGE_STATISTICS struct timespec cpu_average; _Timespec_Divide_by_integer( 10b540: 52 push %edx 10b541: 8d 55 e0 lea -0x20(%ebp),%edx 10b544: 52 push %edx 10b545: 50 push %eax 10b546: 8d 45 a8 lea -0x58(%ebp),%eax 10b549: 50 push %eax 10b54a: e8 45 34 00 00 call 10e994 <_Timespec_Divide_by_integer> &the_stats.total_cpu_time, the_stats.count, &cpu_average ); (*print)( context, 10b54f: 8b 4d e4 mov -0x1c(%ebp),%ecx 10b552: bb d3 4d 62 10 mov $0x10624dd3,%ebx 10b557: 89 c8 mov %ecx,%eax 10b559: f7 eb imul %ebx 10b55b: 89 45 88 mov %eax,-0x78(%ebp) 10b55e: 89 55 8c mov %edx,-0x74(%ebp) 10b561: 8b 45 8c mov -0x74(%ebp),%eax 10b564: c1 f8 06 sar $0x6,%eax 10b567: c1 f9 1f sar $0x1f,%ecx 10b56a: 29 c8 sub %ecx,%eax 10b56c: 50 push %eax 10b56d: ff 75 e0 pushl -0x20(%ebp) 10b570: 8b 4d a4 mov -0x5c(%ebp),%ecx 10b573: 89 c8 mov %ecx,%eax 10b575: f7 eb imul %ebx 10b577: 89 45 80 mov %eax,-0x80(%ebp) 10b57a: 89 55 84 mov %edx,-0x7c(%ebp) 10b57d: 8b 45 84 mov -0x7c(%ebp),%eax 10b580: c1 f8 06 sar $0x6,%eax 10b583: c1 f9 1f sar $0x1f,%ecx 10b586: 29 c8 sub %ecx,%eax 10b588: 50 push %eax 10b589: ff 75 a0 pushl -0x60(%ebp) 10b58c: 8b 4d 9c mov -0x64(%ebp),%ecx 10b58f: 89 c8 mov %ecx,%eax 10b591: f7 eb imul %ebx 10b593: 89 85 78 ff ff ff mov %eax,-0x88(%ebp) 10b599: 89 95 7c ff ff ff mov %edx,-0x84(%ebp) 10b59f: 8b 85 7c ff ff ff mov -0x84(%ebp),%eax 10b5a5: c1 f8 06 sar $0x6,%eax 10b5a8: c1 f9 1f sar $0x1f,%ecx 10b5ab: 29 c8 sub %ecx,%eax 10b5ad: 50 push %eax 10b5ae: ff 75 98 pushl -0x68(%ebp) 10b5b1: 68 88 bc 11 00 push $0x11bc88 10b5b6: ff 75 08 pushl 0x8(%ebp) 10b5b9: ff d7 call *%edi * print Wall time part of statistics */ { #ifdef RTEMS_ENABLE_NANOSECOND_RATE_MONOTONIC_STATISTICS struct timespec wall_average; _Timespec_Divide_by_integer( 10b5bb: 83 c4 2c add $0x2c,%esp 10b5be: 8d 55 e0 lea -0x20(%ebp),%edx 10b5c1: 52 push %edx 10b5c2: ff 75 90 pushl -0x70(%ebp) 10b5c5: 8d 45 c0 lea -0x40(%ebp),%eax 10b5c8: 50 push %eax 10b5c9: e8 c6 33 00 00 call 10e994 <_Timespec_Divide_by_integer> &the_stats.total_wall_time, the_stats.count, &wall_average ); (*print)( context, 10b5ce: 8b 4d e4 mov -0x1c(%ebp),%ecx 10b5d1: 89 c8 mov %ecx,%eax 10b5d3: f7 eb imul %ebx 10b5d5: 89 85 70 ff ff ff mov %eax,-0x90(%ebp) 10b5db: 89 95 74 ff ff ff mov %edx,-0x8c(%ebp) 10b5e1: 8b 85 74 ff ff ff mov -0x8c(%ebp),%eax 10b5e7: c1 f8 06 sar $0x6,%eax 10b5ea: c1 f9 1f sar $0x1f,%ecx 10b5ed: 29 c8 sub %ecx,%eax 10b5ef: 50 push %eax 10b5f0: ff 75 e0 pushl -0x20(%ebp) 10b5f3: 8b 4d bc mov -0x44(%ebp),%ecx 10b5f6: 89 c8 mov %ecx,%eax 10b5f8: f7 eb imul %ebx 10b5fa: 89 85 68 ff ff ff mov %eax,-0x98(%ebp) 10b600: 89 95 6c ff ff ff mov %edx,-0x94(%ebp) 10b606: 8b 85 6c ff ff ff mov -0x94(%ebp),%eax 10b60c: c1 f8 06 sar $0x6,%eax 10b60f: c1 f9 1f sar $0x1f,%ecx 10b612: 29 c8 sub %ecx,%eax 10b614: 50 push %eax 10b615: ff 75 b8 pushl -0x48(%ebp) 10b618: 8b 4d b4 mov -0x4c(%ebp),%ecx 10b61b: 89 c8 mov %ecx,%eax 10b61d: f7 eb imul %ebx 10b61f: 89 85 60 ff ff ff mov %eax,-0xa0(%ebp) 10b625: 89 95 64 ff ff ff mov %edx,-0x9c(%ebp) 10b62b: 8b 85 64 ff ff ff mov -0x9c(%ebp),%eax 10b631: c1 f8 06 sar $0x6,%eax 10b634: c1 f9 1f sar $0x1f,%ecx 10b637: 29 c8 sub %ecx,%eax 10b639: 50 push %eax 10b63a: ff 75 b0 pushl -0x50(%ebp) 10b63d: 68 a8 bc 11 00 push $0x11bca8 10b642: ff 75 08 pushl 0x8(%ebp) 10b645: ff d7 call *%edi 10b647: 83 c4 30 add $0x30,%esp 10b64a: e9 71 fe ff ff jmp 10b4c0 10b64f: 90 nop #endif name[ 0 ] = '\0'; if ( the_status.owner ) { rtems_object_get_name( the_status.owner, sizeof(name), name ); 10b650: 51 push %ecx 10b651: 8d 5d eb lea -0x15(%ebp),%ebx 10b654: 53 push %ebx 10b655: 6a 05 push $0x5 10b657: 50 push %eax 10b658: e8 5b 01 00 00 call 10b7b8 10b65d: 83 c4 10 add $0x10,%esp 10b660: e9 9a fe ff ff jmp 10b4ff =============================================================================== 0010b680 : /* * rtems_rate_monotonic_reset_all_statistics */ void rtems_rate_monotonic_reset_all_statistics( void ) { 10b680: 55 push %ebp 10b681: 89 e5 mov %esp,%ebp 10b683: 53 push %ebx 10b684: 83 ec 04 sub $0x4,%esp /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10b687: a1 78 27 12 00 mov 0x122778,%eax 10b68c: 40 inc %eax 10b68d: a3 78 27 12 00 mov %eax,0x122778 /* * 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 ; 10b692: 8b 1d 88 26 12 00 mov 0x122688,%ebx id <= _Rate_monotonic_Information.maximum_id ; 10b698: 3b 1d 8c 26 12 00 cmp 0x12268c,%ebx 10b69e: 77 15 ja 10b6b5 <== NEVER TAKEN id++ ) { status = rtems_rate_monotonic_reset_statistics( id ); 10b6a0: 83 ec 0c sub $0xc,%esp 10b6a3: 53 push %ebx 10b6a4: e8 17 00 00 00 call 10b6c0 * 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++ ) { 10b6a9: 43 inc %ebx /* * 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 ; 10b6aa: 83 c4 10 add $0x10,%esp 10b6ad: 39 1d 8c 26 12 00 cmp %ebx,0x12268c 10b6b3: 73 eb jae 10b6a0 /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); } 10b6b5: 8b 5d fc mov -0x4(%ebp),%ebx 10b6b8: c9 leave } /* * Done so exit thread dispatching disabled critical section. */ _Thread_Enable_dispatch(); 10b6b9: e9 66 25 00 00 jmp 10dc24 <_Thread_Enable_dispatch> =============================================================================== 001130fc : uint32_t length, uint32_t page_size, rtems_attribute attribute_set, Objects_Id *id ) { 1130fc: 55 push %ebp 1130fd: 89 e5 mov %esp,%ebp 1130ff: 57 push %edi 113100: 56 push %esi 113101: 53 push %ebx 113102: 83 ec 0c sub $0xc,%esp 113105: 8b 7d 08 mov 0x8(%ebp),%edi 113108: 8b 75 0c mov 0xc(%ebp),%esi rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 11310b: 85 ff test %edi,%edi 11310d: 74 25 je 113134 return RTEMS_INVALID_NAME; if ( !starting_address ) 11310f: 85 f6 test %esi,%esi 113111: 74 0f je 113122 return RTEMS_INVALID_ADDRESS; if ( !id ) 113113: 8b 45 1c mov 0x1c(%ebp),%eax 113116: 85 c0 test %eax,%eax 113118: 74 08 je 113122 return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) 11311a: f7 c6 03 00 00 00 test $0x3,%esi 113120: 74 22 je 113144 return_status = RTEMS_SUCCESSFUL; } } _RTEMS_Unlock_allocator(); return return_status; 113122: bb 09 00 00 00 mov $0x9,%ebx } 113127: 89 d8 mov %ebx,%eax 113129: 8d 65 f4 lea -0xc(%ebp),%esp 11312c: 5b pop %ebx 11312d: 5e pop %esi 11312e: 5f pop %edi 11312f: c9 leave 113130: c3 ret 113131: 8d 76 00 lea 0x0(%esi),%esi ) { rtems_status_code return_status; Region_Control *the_region; if ( !rtems_is_name_valid( name ) ) 113134: bb 03 00 00 00 mov $0x3,%ebx } } _RTEMS_Unlock_allocator(); return return_status; } 113139: 89 d8 mov %ebx,%eax 11313b: 8d 65 f4 lea -0xc(%ebp),%esp 11313e: 5b pop %ebx 11313f: 5e pop %esi 113140: 5f pop %edi 113141: c9 leave 113142: c3 ret 113143: 90 nop return RTEMS_INVALID_ADDRESS; if ( !_Addresses_Is_aligned( starting_address ) ) return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 113144: 83 ec 0c sub $0xc,%esp 113147: ff 35 f4 5a 13 00 pushl 0x135af4 11314d: e8 de 22 00 00 call 115430 <_API_Mutex_Lock> #ifdef __cplusplus extern "C" { #endif /** 113152: c7 04 24 c0 58 13 00 movl $0x1358c0,(%esp) 113159: e8 4e 35 00 00 call 1166ac <_Objects_Allocate> 11315e: 89 c3 mov %eax,%ebx the_region = _Region_Allocate(); if ( !the_region ) 113160: 83 c4 10 add $0x10,%esp 113163: 85 c0 test %eax,%eax 113165: 0f 84 9d 00 00 00 je 113208 return_status = RTEMS_TOO_MANY; else { the_region->maximum_segment_size = _Heap_Initialize( 11316b: ff 75 14 pushl 0x14(%ebp) 11316e: ff 75 10 pushl 0x10(%ebp) 113171: 56 push %esi 113172: 8d 40 68 lea 0x68(%eax),%eax 113175: 50 push %eax 113176: e8 5d 30 00 00 call 1161d8 <_Heap_Initialize> 11317b: 89 43 5c mov %eax,0x5c(%ebx) &the_region->Memory, starting_address, length, page_size ); if ( !the_region->maximum_segment_size ) { 11317e: 83 c4 10 add $0x10,%esp 113181: 85 c0 test %eax,%eax 113183: 75 33 jne 1131b8 * @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 113185: 83 ec 08 sub $0x8,%esp 113188: 53 push %ebx 113189: 68 c0 58 13 00 push $0x1358c0 11318e: e8 d9 38 00 00 call 116a6c <_Objects_Free> 113193: bb 08 00 00 00 mov $0x8,%ebx 113198: 83 c4 10 add $0x10,%esp *id = the_region->Object.id; return_status = RTEMS_SUCCESSFUL; } } _RTEMS_Unlock_allocator(); 11319b: 83 ec 0c sub $0xc,%esp 11319e: ff 35 f4 5a 13 00 pushl 0x135af4 1131a4: e8 cf 22 00 00 call 115478 <_API_Mutex_Unlock> 1131a9: 83 c4 10 add $0x10,%esp return return_status; } 1131ac: 89 d8 mov %ebx,%eax 1131ae: 8d 65 f4 lea -0xc(%ebp),%esp 1131b1: 5b pop %ebx 1131b2: 5e pop %esi 1131b3: 5f pop %edi 1131b4: c9 leave 1131b5: c3 ret 1131b6: 66 90 xchg %ax,%ax return_status = RTEMS_INVALID_SIZE; } else { the_region->starting_address = starting_address; 1131b8: 89 73 50 mov %esi,0x50(%ebx) the_region->length = length; 1131bb: 8b 45 10 mov 0x10(%ebp),%eax 1131be: 89 43 54 mov %eax,0x54(%ebx) the_region->page_size = page_size; 1131c1: 8b 45 14 mov 0x14(%ebp),%eax 1131c4: 89 43 58 mov %eax,0x58(%ebx) the_region->attribute_set = attribute_set; 1131c7: 8b 45 18 mov 0x18(%ebp),%eax 1131ca: 89 43 60 mov %eax,0x60(%ebx) the_region->number_of_used_blocks = 0; 1131cd: c7 43 64 00 00 00 00 movl $0x0,0x64(%ebx) _Thread_queue_Initialize( 1131d4: 6a 06 push $0x6 1131d6: 6a 40 push $0x40 1131d8: c1 e8 02 shr $0x2,%eax 1131db: 83 e0 01 and $0x1,%eax 1131de: 50 push %eax 1131df: 8d 43 10 lea 0x10(%ebx),%eax 1131e2: 50 push %eax 1131e3: e8 70 49 00 00 call 117b58 <_Thread_queue_Initialize> 1131e8: 8b 4b 08 mov 0x8(%ebx),%ecx 1131eb: 0f b7 d1 movzwl %cx,%edx 1131ee: a1 dc 58 13 00 mov 0x1358dc,%eax 1131f3: 89 1c 90 mov %ebx,(%eax,%edx,4) 1131f6: 89 7b 0c mov %edi,0xc(%ebx) &_Region_Information, &the_region->Object, (Objects_Name) name ); *id = the_region->Object.id; 1131f9: 8b 45 1c mov 0x1c(%ebp),%eax 1131fc: 89 08 mov %ecx,(%eax) 1131fe: 31 db xor %ebx,%ebx 113200: 83 c4 10 add $0x10,%esp 113203: eb 96 jmp 11319b 113205: 8d 76 00 lea 0x0(%esi),%esi _RTEMS_Lock_allocator(); /* to prevent deletion */ the_region = _Region_Allocate(); if ( !the_region ) 113208: b3 05 mov $0x5,%bl 11320a: eb 8f jmp 11319b =============================================================================== 0011320c : */ rtems_status_code rtems_region_delete( Objects_Id id ) { 11320c: 55 push %ebp 11320d: 89 e5 mov %esp,%ebp 11320f: 53 push %ebx 113210: 83 ec 20 sub $0x20,%esp Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; _RTEMS_Lock_allocator(); 113213: ff 35 f4 5a 13 00 pushl 0x135af4 113219: e8 12 22 00 00 call 115430 <_API_Mutex_Lock> /** * 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 11321e: 83 c4 0c add $0xc,%esp 113221: 8d 45 f8 lea -0x8(%ebp),%eax 113224: 50 push %eax 113225: ff 75 08 pushl 0x8(%ebp) 113228: 68 c0 58 13 00 push $0x1358c0 11322d: e8 6e 39 00 00 call 116ba0 <_Objects_Get_no_protection> 113232: 89 c3 mov %eax,%ebx the_region = _Region_Get( id, &location ); switch ( location ) { 113234: 83 c4 10 add $0x10,%esp 113237: 8b 45 f8 mov -0x8(%ebp),%eax 11323a: 85 c0 test %eax,%eax 11323c: 75 0e jne 11324c case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 5 ); if ( the_region->number_of_used_blocks != 0 ) 11323e: 8b 4b 64 mov 0x64(%ebx),%ecx 113241: 85 c9 test %ecx,%ecx 113243: 74 2f je 113274 113245: bb 0c 00 00 00 mov $0xc,%ebx 11324a: eb 08 jmp 113254 register Region_Control *the_region; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 11324c: 48 dec %eax 11324d: 74 1d je 11326c <== ALWAYS TAKEN 11324f: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 113254: 83 ec 0c sub $0xc,%esp 113257: ff 35 f4 5a 13 00 pushl 0x135af4 11325d: e8 16 22 00 00 call 115478 <_API_Mutex_Unlock> return return_status; } 113262: 89 d8 mov %ebx,%eax 113264: 8b 5d fc mov -0x4(%ebp),%ebx 113267: c9 leave 113268: c3 ret 113269: 8d 76 00 lea 0x0(%esi),%esi register Region_Control *the_region; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 11326c: bb 04 00 00 00 mov $0x4,%ebx 113271: eb e1 jmp 113254 113273: 90 nop 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 ); 113274: 83 ec 08 sub $0x8,%esp 113277: 53 push %ebx 113278: 68 c0 58 13 00 push $0x1358c0 11327d: e8 aa 34 00 00 call 11672c <_Objects_Close> * @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 113282: 58 pop %eax 113283: 5a pop %edx 113284: 53 push %ebx 113285: 68 c0 58 13 00 push $0x1358c0 11328a: e8 dd 37 00 00 call 116a6c <_Objects_Free> 11328f: 31 db xor %ebx,%ebx 113291: 83 c4 10 add $0x10,%esp 113294: eb be jmp 113254 =============================================================================== 00113298 : rtems_status_code rtems_region_extend( Objects_Id id, void *starting_address, uint32_t length ) { 113298: 55 push %ebp 113299: 89 e5 mov %esp,%ebp 11329b: 56 push %esi 11329c: 53 push %ebx 11329d: 83 ec 10 sub $0x10,%esp 1132a0: 8b 75 0c mov 0xc(%ebp),%esi Heap_Extend_status heap_status; Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; Region_Control *the_region; if ( !starting_address ) 1132a3: 85 f6 test %esi,%esi 1132a5: 74 79 je 113320 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); /* to prevent deletion */ 1132a7: 83 ec 0c sub $0xc,%esp 1132aa: ff 35 f4 5a 13 00 pushl 0x135af4 1132b0: e8 7b 21 00 00 call 115430 <_API_Mutex_Lock> /** * 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 1132b5: 83 c4 0c add $0xc,%esp 1132b8: 8d 45 f0 lea -0x10(%ebp),%eax 1132bb: 50 push %eax 1132bc: ff 75 08 pushl 0x8(%ebp) 1132bf: 68 c0 58 13 00 push $0x1358c0 1132c4: e8 d7 38 00 00 call 116ba0 <_Objects_Get_no_protection> 1132c9: 89 c3 mov %eax,%ebx the_region = _Region_Get( id, &location ); switch ( location ) { 1132cb: 83 c4 10 add $0x10,%esp 1132ce: 8b 45 f0 mov -0x10(%ebp),%eax 1132d1: 85 c0 test %eax,%eax 1132d3: 74 23 je 1132f8 1132d5: 48 dec %eax 1132d6: 74 58 je 113330 <== ALWAYS TAKEN switch ( heap_status ) { case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; the_region->maximum_segment_size += amount_extended; return_status = RTEMS_SUCCESSFUL; break; 1132d8: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 1132dd: 83 ec 0c sub $0xc,%esp 1132e0: ff 35 f4 5a 13 00 pushl 0x135af4 1132e6: e8 8d 21 00 00 call 115478 <_API_Mutex_Unlock> 1132eb: 83 c4 10 add $0x10,%esp return return_status; } 1132ee: 89 d8 mov %ebx,%eax 1132f0: 8d 65 f8 lea -0x8(%ebp),%esp 1132f3: 5b pop %ebx 1132f4: 5e pop %esi 1132f5: c9 leave 1132f6: c3 ret 1132f7: 90 nop the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: heap_status = _Heap_Extend( 1132f8: 8d 45 f4 lea -0xc(%ebp),%eax 1132fb: 50 push %eax 1132fc: ff 75 10 pushl 0x10(%ebp) 1132ff: 56 push %esi 113300: 8d 43 68 lea 0x68(%ebx),%eax 113303: 50 push %eax 113304: e8 f7 2b 00 00 call 115f00 <_Heap_Extend> starting_address, length, &amount_extended ); switch ( heap_status ) { 113309: 83 c4 10 add $0x10,%esp 11330c: 83 f8 01 cmp $0x1,%eax 11330f: 74 27 je 113338 113311: 73 2d jae 113340 case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; 113313: 8b 45 f4 mov -0xc(%ebp),%eax 113316: 01 43 54 add %eax,0x54(%ebx) the_region->maximum_segment_size += amount_extended; 113319: 01 43 5c add %eax,0x5c(%ebx) 11331c: 31 db xor %ebx,%ebx 11331e: eb bd jmp 1132dd Heap_Extend_status heap_status; Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; Region_Control *the_region; if ( !starting_address ) 113320: bb 09 00 00 00 mov $0x9,%ebx <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return return_status; } 113325: 89 d8 mov %ebx,%eax <== NOT EXECUTED 113327: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 11332a: 5b pop %ebx <== NOT EXECUTED 11332b: 5e pop %esi <== NOT EXECUTED 11332c: c9 leave <== NOT EXECUTED 11332d: c3 ret <== NOT EXECUTED 11332e: 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 ) { 113330: bb 04 00 00 00 mov $0x4,%ebx 113335: eb a6 jmp 1132dd 113337: 90 nop starting_address, length, &amount_extended ); switch ( heap_status ) { 113338: bb 09 00 00 00 mov $0x9,%ebx 11333d: eb 9e jmp 1132dd 11333f: 90 nop 113340: 83 f8 02 cmp $0x2,%eax 113343: 75 93 jne 1132d8 <== NEVER TAKEN case HEAP_EXTEND_SUCCESSFUL: the_region->length += amount_extended; the_region->maximum_segment_size += amount_extended; return_status = RTEMS_SUCCESSFUL; break; 113345: bb 18 00 00 00 mov $0x18,%ebx 11334a: eb 91 jmp 1132dd =============================================================================== 0011334c : rtems_status_code rtems_region_get_free_information( Objects_Id id, Heap_Information_block *the_info ) { 11334c: 55 push %ebp 11334d: 89 e5 mov %esp,%ebp 11334f: 53 push %ebx 113350: 83 ec 14 sub $0x14,%esp 113353: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !the_info ) 113356: 85 db test %ebx,%ebx 113358: 74 7a je 1133d4 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 11335a: 83 ec 0c sub $0xc,%esp 11335d: ff 35 f4 5a 13 00 pushl 0x135af4 113363: e8 c8 20 00 00 call 115430 <_API_Mutex_Lock> 113368: 83 c4 0c add $0xc,%esp 11336b: 8d 45 f8 lea -0x8(%ebp),%eax 11336e: 50 push %eax 11336f: ff 75 08 pushl 0x8(%ebp) 113372: 68 c0 58 13 00 push $0x1358c0 113377: e8 24 38 00 00 call 116ba0 <_Objects_Get_no_protection> the_region = _Region_Get( id, &location ); switch ( location ) { 11337c: 83 c4 10 add $0x10,%esp 11337f: 8b 55 f8 mov -0x8(%ebp),%edx 113382: 85 d2 test %edx,%edx 113384: 74 22 je 1133a8 113386: 4a dec %edx 113387: 74 57 je 1133e0 <== ALWAYS TAKEN 113389: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 11338e: 83 ec 0c sub $0xc,%esp 113391: ff 35 f4 5a 13 00 pushl 0x135af4 113397: e8 dc 20 00 00 call 115478 <_API_Mutex_Unlock> 11339c: 83 c4 10 add $0x10,%esp return return_status; } 11339f: 89 d8 mov %ebx,%eax 1133a1: 8b 5d fc mov -0x4(%ebp),%ebx 1133a4: c9 leave 1133a5: c3 ret 1133a6: 66 90 xchg %ax,%ax the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: the_info->Used.number = 0; 1133a8: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx) the_info->Used.total = 0; 1133af: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx) the_info->Used.largest = 0; 1133b6: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx) _Heap_Get_free_information( &the_region->Memory, &the_info->Free ); 1133bd: 83 ec 08 sub $0x8,%esp 1133c0: 53 push %ebx 1133c1: 83 c0 68 add $0x68,%eax 1133c4: 50 push %eax 1133c5: e8 3a 2d 00 00 call 116104 <_Heap_Get_free_information> 1133ca: 31 db xor %ebx,%ebx 1133cc: 83 c4 10 add $0x10,%esp 1133cf: eb bd jmp 11338e 1133d1: 8d 76 00 lea 0x0(%esi),%esi { Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !the_info ) 1133d4: b3 09 mov $0x9,%bl break; } _RTEMS_Unlock_allocator(); return return_status; } 1133d6: 89 d8 mov %ebx,%eax 1133d8: 8b 5d fc mov -0x4(%ebp),%ebx 1133db: c9 leave 1133dc: c3 ret 1133dd: 8d 76 00 lea 0x0(%esi),%esi return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 1133e0: bb 04 00 00 00 mov $0x4,%ebx 1133e5: eb a7 jmp 11338e =============================================================================== 001133e8 : rtems_status_code rtems_region_get_information( Objects_Id id, Heap_Information_block *the_info ) { 1133e8: 55 push %ebp 1133e9: 89 e5 mov %esp,%ebp 1133eb: 53 push %ebx 1133ec: 83 ec 14 sub $0x14,%esp 1133ef: 8b 5d 0c mov 0xc(%ebp),%ebx Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !the_info ) 1133f2: 85 db test %ebx,%ebx 1133f4: 74 6a je 113460 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 1133f6: 83 ec 0c sub $0xc,%esp 1133f9: ff 35 f4 5a 13 00 pushl 0x135af4 1133ff: e8 2c 20 00 00 call 115430 <_API_Mutex_Lock> 113404: 83 c4 0c add $0xc,%esp 113407: 8d 45 f8 lea -0x8(%ebp),%eax 11340a: 50 push %eax 11340b: ff 75 08 pushl 0x8(%ebp) 11340e: 68 c0 58 13 00 push $0x1358c0 113413: e8 88 37 00 00 call 116ba0 <_Objects_Get_no_protection> the_region = _Region_Get( id, &location ); switch ( location ) { 113418: 83 c4 10 add $0x10,%esp 11341b: 8b 55 f8 mov -0x8(%ebp),%edx 11341e: 85 d2 test %edx,%edx 113420: 74 22 je 113444 113422: 4a dec %edx 113423: 74 47 je 11346c <== ALWAYS TAKEN 113425: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 11342a: 83 ec 0c sub $0xc,%esp 11342d: ff 35 f4 5a 13 00 pushl 0x135af4 113433: e8 40 20 00 00 call 115478 <_API_Mutex_Unlock> 113438: 83 c4 10 add $0x10,%esp return return_status; } 11343b: 89 d8 mov %ebx,%eax 11343d: 8b 5d fc mov -0x4(%ebp),%ebx 113440: c9 leave 113441: c3 ret 113442: 66 90 xchg %ax,%ax the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _Heap_Get_information( &the_region->Memory, the_info ) != 113444: 83 ec 08 sub $0x8,%esp 113447: 53 push %ebx 113448: 83 c0 68 add $0x68,%eax 11344b: 50 push %eax 11344c: e8 fb 2c 00 00 call 11614c <_Heap_Get_information> 113451: 83 c4 10 add $0x10,%esp 113454: 83 f8 01 cmp $0x1,%eax 113457: 19 db sbb %ebx,%ebx 113459: f7 d3 not %ebx 11345b: 83 e3 09 and $0x9,%ebx 11345e: eb ca jmp 11342a { Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !the_info ) 113460: b3 09 mov $0x9,%bl break; } _RTEMS_Unlock_allocator(); return return_status; } 113462: 89 d8 mov %ebx,%eax 113464: 8b 5d fc mov -0x4(%ebp),%ebx 113467: c9 leave 113468: c3 ret 113469: 8d 76 00 lea 0x0(%esi),%esi return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 11346c: bb 04 00 00 00 mov $0x4,%ebx 113471: eb b7 jmp 11342a =============================================================================== 00113474 : uint32_t size, rtems_option option_set, rtems_interval timeout, void **segment ) { 113474: 55 push %ebp 113475: 89 e5 mov %esp,%ebp 113477: 57 push %edi 113478: 56 push %esi 113479: 53 push %ebx 11347a: 83 ec 1c sub $0x1c,%esp 11347d: 8b 75 0c mov 0xc(%ebp),%esi 113480: 8b 5d 18 mov 0x18(%ebp),%ebx Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; void *the_segment; if ( !segment ) 113483: 85 db test %ebx,%ebx 113485: 0f 84 89 00 00 00 je 113514 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; *segment = NULL; 11348b: c7 03 00 00 00 00 movl $0x0,(%ebx) if ( size == 0 ) 113491: 85 f6 test %esi,%esi 113493: 75 0f jne 1134a4 <== ALWAYS TAKEN 113495: bb 08 00 00 00 mov $0x8,%ebx <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return return_status; } 11349a: 89 d8 mov %ebx,%eax 11349c: 8d 65 f4 lea -0xc(%ebp),%esp 11349f: 5b pop %ebx 1134a0: 5e pop %esi 1134a1: 5f pop %edi 1134a2: c9 leave 1134a3: c3 ret *segment = NULL; if ( size == 0 ) return RTEMS_INVALID_SIZE; _RTEMS_Lock_allocator(); 1134a4: 83 ec 0c sub $0xc,%esp 1134a7: ff 35 f4 5a 13 00 pushl 0x135af4 1134ad: e8 7e 1f 00 00 call 115430 <_API_Mutex_Lock> executing = _Thread_Executing; 1134b2: a1 fc 5a 13 00 mov 0x135afc,%eax 1134b7: 89 45 e0 mov %eax,-0x20(%ebp) 1134ba: 83 c4 0c add $0xc,%esp 1134bd: 8d 45 f0 lea -0x10(%ebp),%eax 1134c0: 50 push %eax 1134c1: ff 75 08 pushl 0x8(%ebp) 1134c4: 68 c0 58 13 00 push $0x1358c0 1134c9: e8 d2 36 00 00 call 116ba0 <_Objects_Get_no_protection> 1134ce: 89 c7 mov %eax,%edi the_region = _Region_Get( id, &location ); switch ( location ) { 1134d0: 83 c4 10 add $0x10,%esp 1134d3: 8b 45 f0 mov -0x10(%ebp),%eax 1134d6: 85 c0 test %eax,%eax 1134d8: 74 26 je 113500 1134da: 48 dec %eax 1134db: 74 2f je 11350c <== ALWAYS TAKEN 1134dd: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 1134e2: 83 ec 0c sub $0xc,%esp 1134e5: ff 35 f4 5a 13 00 pushl 0x135af4 1134eb: e8 88 1f 00 00 call 115478 <_API_Mutex_Unlock> 1134f0: 83 c4 10 add $0x10,%esp return return_status; } 1134f3: 89 d8 mov %ebx,%eax 1134f5: 8d 65 f4 lea -0xc(%ebp),%esp 1134f8: 5b pop %ebx 1134f9: 5e pop %esi 1134fa: 5f pop %edi 1134fb: c9 leave 1134fc: c3 ret 1134fd: 8d 76 00 lea 0x0(%esi),%esi executing = _Thread_Executing; the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( size > the_region->maximum_segment_size ) 113500: 3b 77 5c cmp 0x5c(%edi),%esi 113503: 76 13 jbe 113518 113505: bb 08 00 00 00 mov $0x8,%ebx 11350a: eb d6 jmp 1134e2 _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); _Thread_Enable_dispatch(); return (rtems_status_code) executing->Wait.return_code; 11350c: bb 04 00 00 00 mov $0x4,%ebx 113511: eb cf jmp 1134e2 113513: 90 nop Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; void *the_segment; if ( !segment ) 113514: b3 09 mov $0x9,%bl <== NOT EXECUTED 113516: eb 82 jmp 11349a <== 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. * 113518: 83 ec 08 sub $0x8,%esp 11351b: 56 push %esi 11351c: 8d 47 68 lea 0x68(%edi),%eax 11351f: 50 push %eax 113520: e8 47 29 00 00 call 115e6c <_Heap_Allocate> the_segment = _Region_Allocate_segment( the_region, size ); _Region_Debug_Walk( the_region, 2 ); if ( the_segment ) { 113525: 83 c4 10 add $0x10,%esp 113528: 85 c0 test %eax,%eax 11352a: 74 09 je 113535 the_region->number_of_used_blocks += 1; 11352c: ff 47 64 incl 0x64(%edi) *segment = the_segment; 11352f: 89 03 mov %eax,(%ebx) 113531: 31 db xor %ebx,%ebx 113533: eb ad jmp 1134e2 return_status = RTEMS_SUCCESSFUL; } else if ( _Options_Is_no_wait( option_set ) ) { 113535: f6 45 10 01 testb $0x1,0x10(%ebp) 113539: 74 07 je 113542 11353b: bb 0d 00 00 00 mov $0xd,%ebx 113540: eb a0 jmp 1134e2 /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 113542: a1 38 5a 13 00 mov 0x135a38,%eax 113547: 40 inc %eax 113548: a3 38 5a 13 00 mov %eax,0x135a38 * 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(); 11354d: 83 ec 0c sub $0xc,%esp 113550: ff 35 f4 5a 13 00 pushl 0x135af4 113556: e8 1d 1f 00 00 call 115478 <_API_Mutex_Unlock> executing->Wait.queue = &the_region->Wait_queue; 11355b: 8d 47 10 lea 0x10(%edi),%eax 11355e: 8b 55 e0 mov -0x20(%ebp),%edx 113561: 89 42 44 mov %eax,0x44(%edx) executing->Wait.id = id; 113564: 8b 4d 08 mov 0x8(%ebp),%ecx 113567: 89 4a 20 mov %ecx,0x20(%edx) executing->Wait.count = size; 11356a: 89 72 24 mov %esi,0x24(%edx) executing->Wait.return_argument = segment; 11356d: 89 5a 28 mov %ebx,0x28(%edx) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 113570: c7 47 40 01 00 00 00 movl $0x1,0x40(%edi) _Thread_queue_Enter_critical_section( &the_region->Wait_queue ); _Thread_queue_Enqueue( &the_region->Wait_queue, timeout ); 113577: 83 c4 0c add $0xc,%esp 11357a: 68 34 7c 11 00 push $0x117c34 11357f: ff 75 14 pushl 0x14(%ebp) 113582: 50 push %eax 113583: e8 5c 43 00 00 call 1178e4 <_Thread_queue_Enqueue_with_handler> _Thread_Enable_dispatch(); 113588: e8 97 3e 00 00 call 117424 <_Thread_Enable_dispatch> return (rtems_status_code) executing->Wait.return_code; 11358d: 8b 45 e0 mov -0x20(%ebp),%eax 113590: 8b 58 34 mov 0x34(%eax),%ebx 113593: 83 c4 10 add $0x10,%esp 113596: e9 ff fe ff ff jmp 11349a =============================================================================== 0011359c : rtems_status_code rtems_region_get_segment_size( Objects_Id id, void *segment, size_t *size ) { 11359c: 55 push %ebp 11359d: 89 e5 mov %esp,%ebp 11359f: 56 push %esi 1135a0: 53 push %ebx 1135a1: 83 ec 10 sub $0x10,%esp 1135a4: 8b 75 0c mov 0xc(%ebp),%esi 1135a7: 8b 5d 10 mov 0x10(%ebp),%ebx Objects_Locations location; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; register Region_Control *the_region; if ( !segment ) 1135aa: 85 f6 test %esi,%esi 1135ac: 74 6a je 113618 return RTEMS_INVALID_ADDRESS; if ( !size ) 1135ae: 85 db test %ebx,%ebx 1135b0: 74 66 je 113618 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 1135b2: 83 ec 0c sub $0xc,%esp 1135b5: ff 35 f4 5a 13 00 pushl 0x135af4 1135bb: e8 70 1e 00 00 call 115430 <_API_Mutex_Lock> * begin at @a starting_address. * * @param[in] the_heap is the heap to operate upon 1135c0: 83 c4 0c add $0xc,%esp 1135c3: 8d 45 f4 lea -0xc(%ebp),%eax 1135c6: 50 push %eax 1135c7: ff 75 08 pushl 0x8(%ebp) 1135ca: 68 c0 58 13 00 push $0x1358c0 1135cf: e8 cc 35 00 00 call 116ba0 <_Objects_Get_no_protection> the_region = _Region_Get( id, &location ); switch ( location ) { 1135d4: 83 c4 10 add $0x10,%esp 1135d7: 8b 55 f4 mov -0xc(%ebp),%edx 1135da: 85 d2 test %edx,%edx 1135dc: 74 22 je 113600 1135de: 4a dec %edx 1135df: 74 47 je 113628 <== ALWAYS TAKEN 1135e1: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 1135e6: 83 ec 0c sub $0xc,%esp 1135e9: ff 35 f4 5a 13 00 pushl 0x135af4 1135ef: e8 84 1e 00 00 call 115478 <_API_Mutex_Unlock> 1135f4: 83 c4 10 add $0x10,%esp return return_status; } 1135f7: 89 d8 mov %ebx,%eax 1135f9: 8d 65 f8 lea -0x8(%ebp),%esp 1135fc: 5b pop %ebx 1135fd: 5e pop %esi 1135fe: c9 leave 1135ff: c3 ret the_region = _Region_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Heap_Size_of_user_area( &the_region->Memory, segment, size ) ) 113600: 52 push %edx 113601: 53 push %ebx 113602: 56 push %esi 113603: 83 c0 68 add $0x68,%eax 113606: 50 push %eax 113607: e8 a0 2f 00 00 call 1165ac <_Heap_Size_of_user_area> 11360c: 83 c4 10 add $0x10,%esp 11360f: 3c 01 cmp $0x1,%al 113611: 19 db sbb %ebx,%ebx 113613: 83 e3 09 and $0x9,%ebx 113616: eb ce jmp 1135e6 return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); return return_status; 113618: bb 09 00 00 00 mov $0x9,%ebx } 11361d: 89 d8 mov %ebx,%eax 11361f: 8d 65 f8 lea -0x8(%ebp),%esp 113622: 5b pop %ebx 113623: 5e pop %esi 113624: c9 leave 113625: c3 ret 113626: 66 90 xchg %ax,%ax return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 113628: bb 04 00 00 00 mov $0x4,%ebx 11362d: eb b7 jmp 1135e6 =============================================================================== 00113654 : Objects_Id id, void *segment, size_t size, size_t *old_size ) { 113654: 55 push %ebp 113655: 89 e5 mov %esp,%ebp 113657: 57 push %edi 113658: 56 push %esi 113659: 53 push %ebx 11365a: 83 ec 1c sub $0x1c,%esp 11365d: 8b 7d 14 mov 0x14(%ebp),%edi uint32_t osize; rtems_status_code return_status = RTEMS_INTERNAL_ERROR; Heap_Resize_status status; register Region_Control *the_region; if ( !old_size ) 113660: 85 ff test %edi,%edi 113662: 0f 84 bc 00 00 00 je 113724 return RTEMS_INVALID_ADDRESS; _RTEMS_Lock_allocator(); 113668: 83 ec 0c sub $0xc,%esp 11366b: ff 35 f4 5a 13 00 pushl 0x135af4 113671: e8 ba 1d 00 00 call 115430 <_API_Mutex_Lock> 113676: 83 c4 0c add $0xc,%esp 113679: 8d 45 ec lea -0x14(%ebp),%eax 11367c: 50 push %eax 11367d: ff 75 08 pushl 0x8(%ebp) 113680: 68 c0 58 13 00 push $0x1358c0 113685: e8 16 35 00 00 call 116ba0 <_Objects_Get_no_protection> 11368a: 89 c6 mov %eax,%esi the_region = _Region_Get( id, &location ); switch ( location ) { 11368c: 83 c4 10 add $0x10,%esp 11368f: 8b 45 ec mov -0x14(%ebp),%eax 113692: 85 c0 test %eax,%eax 113694: 74 2a je 1136c0 113696: 48 dec %eax 113697: 0f 84 97 00 00 00 je 113734 <== ALWAYS TAKEN 11369d: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 1136a2: 83 ec 0c sub $0xc,%esp 1136a5: ff 35 f4 5a 13 00 pushl 0x135af4 1136ab: e8 c8 1d 00 00 call 115478 <_API_Mutex_Unlock> 1136b0: 83 c4 10 add $0x10,%esp return return_status; } 1136b3: 89 d8 mov %ebx,%eax 1136b5: 8d 65 f4 lea -0xc(%ebp),%esp 1136b8: 5b pop %ebx 1136b9: 5e pop %esi 1136ba: 5f pop %edi 1136bb: c9 leave 1136bc: c3 ret 1136bd: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_LOCAL: _Region_Debug_Walk( the_region, 7 ); status = _Heap_Resize_block( 1136c0: 83 ec 0c sub $0xc,%esp 1136c3: 8d 45 f0 lea -0x10(%ebp),%eax 1136c6: 50 push %eax 1136c7: 8d 45 e8 lea -0x18(%ebp),%eax 1136ca: 50 push %eax 1136cb: ff 75 10 pushl 0x10(%ebp) 1136ce: ff 75 0c pushl 0xc(%ebp) 1136d1: 8d 46 68 lea 0x68(%esi),%eax 1136d4: 50 push %eax 1136d5: e8 e6 2c 00 00 call 1163c0 <_Heap_Resize_block> 1136da: 89 c3 mov %eax,%ebx segment, (uint32_t) size, &osize, &avail_size ); *old_size = (uint32_t) osize; 1136dc: 8b 45 e8 mov -0x18(%ebp),%eax 1136df: 89 07 mov %eax,(%edi) _Region_Debug_Walk( the_region, 8 ); if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 ) 1136e1: 83 c4 20 add $0x20,%esp 1136e4: 85 db test %ebx,%ebx 1136e6: 75 24 jne 11370c <== ALWAYS TAKEN 1136e8: 8b 45 f0 mov -0x10(%ebp),%eax <== NOT EXECUTED 1136eb: 85 c0 test %eax,%eax <== NOT EXECUTED 1136ed: 75 51 jne 113740 <== NOT EXECUTED _Region_Process_queue( the_region ); /* unlocks allocator */ else _RTEMS_Unlock_allocator(); 1136ef: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1136f2: ff 35 f4 5a 13 00 pushl 0x135af4 <== NOT EXECUTED 1136f8: e8 7b 1d 00 00 call 115478 <_API_Mutex_Unlock> <== NOT EXECUTED 1136fd: 31 db xor %ebx,%ebx <== NOT EXECUTED 1136ff: 83 c4 10 add $0x10,%esp <== NOT EXECUTED break; } _RTEMS_Unlock_allocator(); return return_status; } 113702: 89 d8 mov %ebx,%eax <== NOT EXECUTED 113704: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 113707: 5b pop %ebx <== NOT EXECUTED 113708: 5e pop %esi <== NOT EXECUTED 113709: 5f pop %edi <== NOT EXECUTED 11370a: c9 leave <== NOT EXECUTED 11370b: 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(); 11370c: 83 ec 0c sub $0xc,%esp 11370f: ff 35 f4 5a 13 00 pushl 0x135af4 113715: e8 5e 1d 00 00 call 115478 <_API_Mutex_Unlock> return 11371a: 83 c4 10 add $0x10,%esp 11371d: 83 fb 01 cmp $0x1,%ebx 113720: 74 32 je 113754 <== NEVER TAKEN 113722: 66 90 xchg %ax,%ax return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); return return_status; 113724: bb 09 00 00 00 mov $0x9,%ebx } 113729: 89 d8 mov %ebx,%eax 11372b: 8d 65 f4 lea -0xc(%ebp),%esp 11372e: 5b pop %ebx 11372f: 5e pop %esi 113730: 5f pop %edi 113731: c9 leave 113732: c3 ret 113733: 90 nop if ( status == HEAP_RESIZE_SUCCESSFUL && avail_size > 0 ) _Region_Process_queue( the_region ); /* unlocks allocator */ else _RTEMS_Unlock_allocator(); return 113734: bb 04 00 00 00 mov $0x4,%ebx 113739: e9 64 ff ff ff jmp 1136a2 11373e: 66 90 xchg %ax,%ax *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 */ 113740: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 113743: 56 push %esi <== NOT EXECUTED 113744: e8 6b 6b 00 00 call 11a2b4 <_Region_Process_queue> <== NOT EXECUTED 113749: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 11374c: e9 62 ff ff ff jmp 1136b3 <== NOT EXECUTED 113751: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED else _RTEMS_Unlock_allocator(); return 113754: b3 0d mov $0xd,%bl <== NOT EXECUTED 113756: e9 58 ff ff ff jmp 1136b3 <== NOT EXECUTED =============================================================================== 0011375c : rtems_status_code rtems_region_return_segment( Objects_Id id, void *segment ) { 11375c: 55 push %ebp 11375d: 89 e5 mov %esp,%ebp 11375f: 53 push %ebx 113760: 83 ec 20 sub $0x20,%esp uint32_t size; #endif int status; register Region_Control *the_region; _RTEMS_Lock_allocator(); 113763: ff 35 f4 5a 13 00 pushl 0x135af4 113769: e8 c2 1c 00 00 call 115430 <_API_Mutex_Lock> 11376e: 83 c4 0c add $0xc,%esp 113771: 8d 45 f8 lea -0x8(%ebp),%eax 113774: 50 push %eax 113775: ff 75 08 pushl 0x8(%ebp) 113778: 68 c0 58 13 00 push $0x1358c0 11377d: e8 1e 34 00 00 call 116ba0 <_Objects_Get_no_protection> 113782: 89 c3 mov %eax,%ebx the_region = _Region_Get( id, &location ); switch ( location ) { 113784: 83 c4 10 add $0x10,%esp 113787: 8b 45 f8 mov -0x8(%ebp),%eax 11378a: 85 c0 test %eax,%eax 11378c: 75 1e jne 1137ac ); /** * 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. 11378e: 83 ec 08 sub $0x8,%esp 113791: ff 75 0c pushl 0xc(%ebp) 113794: 8d 43 68 lea 0x68(%ebx),%eax 113797: 50 push %eax 113798: e8 07 28 00 00 call 115fa4 <_Heap_Free> #endif status = _Region_Free_segment( the_region, segment ); _Region_Debug_Walk( the_region, 4 ); if ( !status ) 11379d: 83 c4 10 add $0x10,%esp 1137a0: 84 c0 test %al,%al 1137a2: 75 30 jne 1137d4 else { the_region->number_of_used_blocks -= 1; _Region_Process_queue(the_region); /* unlocks allocator */ return RTEMS_SUCCESSFUL; 1137a4: bb 09 00 00 00 mov $0x9,%ebx 1137a9: eb 09 jmp 1137b4 1137ab: 90 nop register Region_Control *the_region; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 1137ac: 48 dec %eax 1137ad: 74 1d je 1137cc <== ALWAYS TAKEN 1137af: bb 19 00 00 00 mov $0x19,%ebx <== NOT EXECUTED case OBJECTS_ERROR: return_status = RTEMS_INVALID_ID; break; } _RTEMS_Unlock_allocator(); 1137b4: 83 ec 0c sub $0xc,%esp 1137b7: ff 35 f4 5a 13 00 pushl 0x135af4 1137bd: e8 b6 1c 00 00 call 115478 <_API_Mutex_Unlock> 1137c2: 83 c4 10 add $0x10,%esp return return_status; } 1137c5: 89 d8 mov %ebx,%eax 1137c7: 8b 5d fc mov -0x4(%ebp),%ebx 1137ca: c9 leave 1137cb: c3 ret register Region_Control *the_region; _RTEMS_Lock_allocator(); the_region = _Region_Get( id, &location ); switch ( location ) { 1137cc: bb 04 00 00 00 mov $0x4,%ebx 1137d1: eb e1 jmp 1137b4 1137d3: 90 nop if ( !status ) return_status = RTEMS_INVALID_ADDRESS; else { the_region->number_of_used_blocks -= 1; 1137d4: ff 4b 64 decl 0x64(%ebx) _Region_Process_queue(the_region); /* unlocks allocator */ 1137d7: 83 ec 0c sub $0xc,%esp 1137da: 53 push %ebx 1137db: e8 d4 6a 00 00 call 11a2b4 <_Region_Process_queue> 1137e0: 31 db xor %ebx,%ebx 1137e2: 83 c4 10 add $0x10,%esp 1137e5: eb de jmp 1137c5 =============================================================================== 0010a170 : uint32_t count, rtems_attribute attribute_set, rtems_task_priority priority_ceiling, rtems_id *id ) { 10a170: 55 push %ebp 10a171: 89 e5 mov %esp,%ebp 10a173: 57 push %edi 10a174: 56 push %esi 10a175: 53 push %ebx 10a176: 83 ec 2c sub $0x2c,%esp 10a179: 8b 7d 08 mov 0x8(%ebp),%edi register Semaphore_Control *the_semaphore; CORE_mutex_Attributes the_mutex_attributes; CORE_semaphore_Attributes the_semaphore_attributes; if ( !rtems_is_name_valid( name ) ) 10a17c: 85 ff test %edi,%edi 10a17e: 74 64 je 10a1e4 return RTEMS_INVALID_NAME; if ( !id ) 10a180: 8b 4d 18 mov 0x18(%ebp),%ecx 10a183: 85 c9 test %ecx,%ecx 10a185: 0f 84 01 01 00 00 je 10a28c <== NEVER TAKEN return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 10a18b: 8b 45 10 mov 0x10(%ebp),%eax 10a18e: 25 c0 00 00 00 and $0xc0,%eax 10a193: 74 1f je 10a1b4 * @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, 10a195: 8b 5d 10 mov 0x10(%ebp),%ebx 10a198: 83 e3 30 and $0x30,%ebx _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 10a19b: 83 fb 10 cmp $0x10,%ebx 10a19e: 74 34 je 10a1d4 10a1a0: 83 fb 20 cmp $0x20,%ebx 10a1a3: 74 2f je 10a1d4 name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 10a1a5: b8 0b 00 00 00 mov $0xb,%eax } 10a1aa: 8d 65 f4 lea -0xc(%ebp),%esp 10a1ad: 5b pop %ebx 10a1ae: 5e pop %esi 10a1af: 5f pop %edi 10a1b0: c9 leave 10a1b1: c3 ret 10a1b2: 66 90 xchg %ax,%ax return RTEMS_NOT_DEFINED; } else #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || 10a1b4: 8b 5d 10 mov 0x10(%ebp),%ebx 10a1b7: 83 e3 30 and $0x30,%ebx 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 ) ) 10a1ba: 85 db test %ebx,%ebx 10a1bc: 74 36 je 10a1f4 10a1be: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 10a1c2: 76 30 jbe 10a1f4 10a1c4: b8 0a 00 00 00 mov $0xa,%eax 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a1c9: 8d 65 f4 lea -0xc(%ebp),%esp 10a1cc: 5b pop %ebx 10a1cd: 5e pop %esi 10a1ce: 5f pop %edi 10a1cf: c9 leave 10a1d0: c3 ret 10a1d1: 8d 76 00 lea 0x0(%esi),%esi #endif if ( _Attributes_Is_inherit_priority( attribute_set ) || _Attributes_Is_priority_ceiling( attribute_set ) ) { if ( ! ( (_Attributes_Is_binary_semaphore( attribute_set ) || 10a1d4: f6 45 10 04 testb $0x4,0x10(%ebp) 10a1d8: 74 cb je 10a1a5 _Attributes_Is_priority( attribute_set ) ) ) return RTEMS_NOT_DEFINED; } if ( _Attributes_Is_inherit_priority( attribute_set ) && 10a1da: 3d c0 00 00 00 cmp $0xc0,%eax 10a1df: 75 d9 jne 10a1ba 10a1e1: eb c2 jmp 10a1a5 10a1e3: 90 nop { register Semaphore_Control *the_semaphore; CORE_mutex_Attributes the_mutex_attributes; CORE_semaphore_Attributes the_semaphore_attributes; if ( !rtems_is_name_valid( name ) ) 10a1e4: b8 03 00 00 00 mov $0x3,%eax 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10a1e9: 8d 65 f4 lea -0xc(%ebp),%esp 10a1ec: 5b pop %ebx 10a1ed: 5e pop %esi 10a1ee: 5f pop %edi 10a1ef: c9 leave 10a1f0: c3 ret 10a1f1: 8d 76 00 lea 0x0(%esi),%esi /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a1f4: a1 58 e6 11 00 mov 0x11e658,%eax 10a1f9: 40 inc %eax 10a1fa: a3 58 e6 11 00 mov %eax,0x11e658 #ifdef __cplusplus extern "C" { #endif /** 10a1ff: 83 ec 0c sub $0xc,%esp 10a202: 68 a0 e5 11 00 push $0x11e5a0 10a207: e8 a8 13 00 00 call 10b5b4 <_Objects_Allocate> 10a20c: 89 c6 mov %eax,%esi _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { 10a20e: 83 c4 10 add $0x10,%esp 10a211: 85 c0 test %eax,%eax 10a213: 0f 84 eb 00 00 00 je 10a304 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } #endif the_semaphore->attribute_set = attribute_set; 10a219: 8b 45 10 mov 0x10(%ebp),%eax 10a21c: 89 46 10 mov %eax,0x10(%esi) * 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 ) ) { 10a21f: 85 db test %ebx,%ebx 10a221: 74 75 je 10a298 CORE_mutex_Status mutex_status; if ( _Attributes_Is_inherit_priority( attribute_set ) ) 10a223: a8 40 test $0x40,%al 10a225: 0f 84 c5 00 00 00 je 10a2f0 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT; 10a22b: c7 45 e4 02 00 00 00 movl $0x2,-0x1c(%ebp) the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY; else the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_FIFO; if ( _Attributes_Is_binary_semaphore( attribute_set ) ) { 10a232: 83 fb 10 cmp $0x10,%ebx 10a235: 0f 84 d9 00 00 00 je 10a314 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; 10a23b: c7 45 dc 02 00 00 00 movl $0x2,-0x24(%ebp) the_mutex_attributes.only_owner_release = FALSE; 10a242: c6 45 e0 00 movb $0x0,-0x20(%ebp) } the_mutex_attributes.priority_ceiling = priority_ceiling; 10a246: 8b 45 14 mov 0x14(%ebp),%eax 10a249: 89 45 e8 mov %eax,-0x18(%ebp) mutex_status = _CORE_mutex_Initialize( 10a24c: 52 push %edx 10a24d: 31 c0 xor %eax,%eax 10a24f: 83 7d 0c 01 cmpl $0x1,0xc(%ebp) 10a253: 0f 94 c0 sete %al 10a256: 50 push %eax 10a257: 8d 45 dc lea -0x24(%ebp),%eax 10a25a: 50 push %eax 10a25b: 8d 46 14 lea 0x14(%esi),%eax 10a25e: 50 push %eax 10a25f: e8 a0 0c 00 00 call 10af04 <_CORE_mutex_Initialize> &the_semaphore->Core_control.mutex, &the_mutex_attributes, (count == 1) ? CORE_MUTEX_UNLOCKED : CORE_MUTEX_LOCKED ); if ( mutex_status == CORE_MUTEX_STATUS_CEILING_VIOLATED ) { 10a264: 83 c4 10 add $0x10,%esp 10a267: 83 f8 06 cmp $0x6,%eax 10a26a: 75 61 jne 10a2cd <== ALWAYS TAKEN * @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 10a26c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10a26f: 56 push %esi <== NOT EXECUTED 10a270: 68 a0 e5 11 00 push $0x11e5a0 <== NOT EXECUTED 10a275: e8 fa 16 00 00 call 10b974 <_Objects_Free> <== NOT EXECUTED _Semaphore_Free( the_semaphore ); _Thread_Enable_dispatch(); 10a27a: e8 6d 20 00 00 call 10c2ec <_Thread_Enable_dispatch><== NOT EXECUTED 10a27f: b8 13 00 00 00 mov $0x13,%eax <== NOT EXECUTED 10a284: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10a287: e9 1e ff ff ff jmp 10a1aa <== NOT EXECUTED CORE_semaphore_Attributes the_semaphore_attributes; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 10a28c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a291: e9 14 ff ff ff jmp 10a1aa <== NOT EXECUTED 10a296: 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; 10a298: 31 c0 xor %eax,%eax 10a29a: f6 45 10 04 testb $0x4,0x10(%ebp) 10a29e: 0f 95 c0 setne %al 10a2a1: 89 45 f0 mov %eax,-0x10(%ebp) /* * This effectively disables limit checking. */ the_semaphore_attributes.maximum_count = 0xFFFFFFFF; 10a2a4: c7 45 ec ff ff ff ff movl $0xffffffff,-0x14(%ebp) /* * The following are just to make Purify happy. */ the_mutex_attributes.lock_nesting_behavior = CORE_MUTEX_NESTING_ACQUIRES; 10a2ab: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) the_mutex_attributes.priority_ceiling = PRIORITY_MINIMUM; 10a2b2: c7 45 e8 00 00 00 00 movl $0x0,-0x18(%ebp) _CORE_semaphore_Initialize( 10a2b9: 50 push %eax 10a2ba: ff 75 0c pushl 0xc(%ebp) 10a2bd: 8d 45 ec lea -0x14(%ebp),%eax 10a2c0: 50 push %eax 10a2c1: 8d 46 14 lea 0x14(%esi),%eax 10a2c4: 50 push %eax 10a2c5: e8 f2 0e 00 00 call 10b1bc <_CORE_semaphore_Initialize> 10a2ca: 83 c4 10 add $0x10,%esp 10a2cd: 8b 4e 08 mov 0x8(%esi),%ecx 10a2d0: 0f b7 d1 movzwl %cx,%edx 10a2d3: a1 bc e5 11 00 mov 0x11e5bc,%eax 10a2d8: 89 34 90 mov %esi,(%eax,%edx,4) 10a2db: 89 7e 0c mov %edi,0xc(%esi) &_Semaphore_Information, &the_semaphore->Object, (Objects_Name) name ); *id = the_semaphore->Object.id; 10a2de: 8b 45 18 mov 0x18(%ebp),%eax 10a2e1: 89 08 mov %ecx,(%eax) the_semaphore->Object.id, name, 0 /* Not used */ ); #endif _Thread_Enable_dispatch(); 10a2e3: e8 04 20 00 00 call 10c2ec <_Thread_Enable_dispatch> 10a2e8: 31 c0 xor %eax,%eax 10a2ea: e9 bb fe ff ff jmp 10a1aa 10a2ef: 90 nop 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 ) ) 10a2f0: 80 7d 10 00 cmpb $0x0,0x10(%ebp) 10a2f4: 79 43 jns 10a339 the_mutex_attributes.discipline = CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING; 10a2f6: c7 45 e4 03 00 00 00 movl $0x3,-0x1c(%ebp) 10a2fd: e9 30 ff ff ff jmp 10a232 10a302: 66 90 xchg %ax,%ax _Thread_Disable_dispatch(); /* prevents deletion */ the_semaphore = _Semaphore_Allocate(); if ( !the_semaphore ) { _Thread_Enable_dispatch(); 10a304: e8 e3 1f 00 00 call 10c2ec <_Thread_Enable_dispatch> 10a309: b8 05 00 00 00 mov $0x5,%eax 10a30e: e9 97 fe ff ff jmp 10a1aa 10a313: 90 nop 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; 10a314: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) switch ( the_mutex_attributes.discipline ) { 10a31b: 8b 45 e4 mov -0x1c(%ebp),%eax 10a31e: 83 f8 01 cmp $0x1,%eax 10a321: 0f 86 1b ff ff ff jbe 10a242 10a327: 83 f8 03 cmp $0x3,%eax 10a32a: 0f 87 16 ff ff ff ja 10a246 <== NEVER TAKEN 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; 10a330: c6 45 e0 01 movb $0x1,-0x20(%ebp) 10a334: e9 0d ff ff ff jmp 10a246 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; 10a339: 31 c0 xor %eax,%eax 10a33b: f6 45 10 04 testb $0x4,0x10(%ebp) 10a33f: 0f 95 c0 setne %al 10a342: 89 45 e4 mov %eax,-0x1c(%ebp) 10a345: e9 e8 fe ff ff jmp 10a232 =============================================================================== 0010a34c : #endif rtems_status_code rtems_semaphore_delete( rtems_id id ) { 10a34c: 55 push %ebp 10a34d: 89 e5 mov %esp,%ebp 10a34f: 53 push %ebx 10a350: 83 ec 18 sub $0x18,%esp * 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 10a353: 8d 45 f8 lea -0x8(%ebp),%eax 10a356: 50 push %eax 10a357: ff 75 08 pushl 0x8(%ebp) 10a35a: 68 a0 e5 11 00 push $0x11e5a0 10a35f: e8 44 17 00 00 call 10baa8 <_Objects_Get> 10a364: 89 c3 mov %eax,%ebx register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 10a366: 83 c4 10 add $0x10,%esp 10a369: 8b 4d f8 mov -0x8(%ebp),%ecx 10a36c: 85 c9 test %ecx,%ecx 10a36e: 74 0c je 10a37c 10a370: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a375: 8b 5d fc mov -0x4(%ebp),%ebx 10a378: c9 leave 10a379: c3 ret 10a37a: 66 90 xchg %ax,%ax ); /** * This function tries to resize in place the block that is pointed to by the * @a starting_address to the new @a size. * 10a37c: 8b 40 10 mov 0x10(%eax),%eax the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10a37f: 83 e0 30 and $0x30,%eax 10a382: 74 58 je 10a3dc if ( _CORE_mutex_Is_locked( &the_semaphore->Core_control.mutex ) && 10a384: 8b 53 64 mov 0x64(%ebx),%edx 10a387: 85 d2 test %edx,%edx 10a389: 75 15 jne 10a3a0 10a38b: 83 f8 20 cmp $0x20,%eax 10a38e: 74 10 je 10a3a0 !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); 10a390: e8 57 1f 00 00 call 10c2ec <_Thread_Enable_dispatch> 10a395: b8 0c 00 00 00 mov $0xc,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a39a: 8b 5d fc mov -0x4(%ebp),%ebx 10a39d: c9 leave 10a39e: c3 ret 10a39f: 90 nop !_Attributes_Is_simple_binary_semaphore( the_semaphore->attribute_set ) ) { _Thread_Enable_dispatch(); return RTEMS_RESOURCE_IN_USE; } _CORE_mutex_Flush( 10a3a0: 50 push %eax 10a3a1: 6a 04 push $0x4 10a3a3: 6a 00 push $0x0 10a3a5: 8d 43 14 lea 0x14(%ebx),%eax 10a3a8: 50 push %eax 10a3a9: e8 4a 0b 00 00 call 10aef8 <_CORE_mutex_Flush> 10a3ae: 83 c4 10 add $0x10,%esp SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_SEMAPHORE_WAS_DELETED ); } _Objects_Close( &_Semaphore_Information, &the_semaphore->Object ); 10a3b1: 83 ec 08 sub $0x8,%esp 10a3b4: 53 push %ebx 10a3b5: 68 a0 e5 11 00 push $0x11e5a0 10a3ba: e8 75 12 00 00 call 10b634 <_Objects_Close> * @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 10a3bf: 58 pop %eax 10a3c0: 5a pop %edx 10a3c1: 53 push %ebx 10a3c2: 68 a0 e5 11 00 push $0x11e5a0 10a3c7: e8 a8 15 00 00 call 10b974 <_Objects_Free> 0, /* Not used */ 0 /* Not used */ ); } #endif _Thread_Enable_dispatch(); 10a3cc: e8 1b 1f 00 00 call 10c2ec <_Thread_Enable_dispatch> 10a3d1: 31 c0 xor %eax,%eax 10a3d3: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a3d6: 8b 5d fc mov -0x4(%ebp),%ebx 10a3d9: c9 leave 10a3da: c3 ret 10a3db: 90 nop &the_semaphore->Core_control.mutex, SEMAPHORE_MP_OBJECT_WAS_DELETED, CORE_MUTEX_WAS_DELETED ); } else { _CORE_semaphore_Flush( 10a3dc: 51 push %ecx 10a3dd: 6a 02 push $0x2 10a3df: 6a 00 push $0x0 10a3e1: 8d 43 14 lea 0x14(%ebx),%eax 10a3e4: 50 push %eax 10a3e5: e8 c6 0d 00 00 call 10b1b0 <_CORE_semaphore_Flush> 10a3ea: 83 c4 10 add $0x10,%esp 10a3ed: eb c2 jmp 10a3b1 =============================================================================== 00113a68 : #endif rtems_status_code rtems_semaphore_flush( rtems_id id ) { 113a68: 55 push %ebp 113a69: 89 e5 mov %esp,%ebp 113a6b: 83 ec 1c sub $0x1c,%esp * 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 113a6e: 8d 45 fc lea -0x4(%ebp),%eax 113a71: 50 push %eax 113a72: ff 75 08 pushl 0x8(%ebp) 113a75: 68 00 59 13 00 push $0x135900 113a7a: e8 61 31 00 00 call 116be0 <_Objects_Get> register Semaphore_Control *the_semaphore; Objects_Locations location; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 113a7f: 83 c4 10 add $0x10,%esp 113a82: 8b 55 fc mov -0x4(%ebp),%edx 113a85: 85 d2 test %edx,%edx 113a87: 74 07 je 113a90 113a89: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 113a8e: c9 leave 113a8f: c3 ret the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 113a90: f6 40 10 30 testb $0x30,0x10(%eax) 113a94: 75 1a jne 113ab0 <== ALWAYS TAKEN &the_semaphore->Core_control.mutex, SEND_OBJECT_WAS_DELETED, CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT ); } else { _CORE_semaphore_Flush( 113a96: 52 push %edx <== NOT EXECUTED 113a97: 6a 01 push $0x1 <== NOT EXECUTED 113a99: 6a 00 push $0x0 <== NOT EXECUTED 113a9b: 83 c0 14 add $0x14,%eax <== NOT EXECUTED 113a9e: 50 push %eax <== NOT EXECUTED 113a9f: e8 80 21 00 00 call 115c24 <_CORE_semaphore_Flush> <== NOT EXECUTED 113aa4: 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(); 113aa7: e8 78 39 00 00 call 117424 <_Thread_Enable_dispatch> 113aac: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 113aae: c9 leave 113aaf: c3 ret the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { _CORE_mutex_Flush( 113ab0: 51 push %ecx 113ab1: 6a 01 push $0x1 113ab3: 6a 00 push $0x0 113ab5: 83 c0 14 add $0x14,%eax 113ab8: 50 push %eax 113ab9: e8 ae 1e 00 00 call 11596c <_CORE_mutex_Flush> 113abe: 83 c4 10 add $0x10,%esp 113ac1: eb e4 jmp 113aa7 =============================================================================== 0010a3f0 : rtems_status_code rtems_semaphore_obtain( rtems_id id, rtems_option option_set, rtems_interval timeout ) { 10a3f0: 55 push %ebp 10a3f1: 89 e5 mov %esp,%ebp 10a3f3: 56 push %esi 10a3f4: 53 push %ebx 10a3f5: 83 ec 10 sub $0x10,%esp 10a3f8: 8b 5d 08 mov 0x8(%ebp),%ebx * @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 10a3fb: 8d 45 f0 lea -0x10(%ebp),%eax 10a3fe: 50 push %eax 10a3ff: 8d 45 f4 lea -0xc(%ebp),%eax 10a402: 50 push %eax 10a403: 53 push %ebx 10a404: 68 a0 e5 11 00 push $0x11e5a0 10a409: e8 4e 16 00 00 call 10ba5c <_Objects_Get_isr_disable> 10a40e: 89 c2 mov %eax,%edx register Semaphore_Control *the_semaphore; Objects_Locations location; ISR_Level level; the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { 10a410: 83 c4 10 add $0x10,%esp 10a413: 8b 4d f4 mov -0xc(%ebp),%ecx 10a416: 85 c9 test %ecx,%ecx 10a418: 74 0e je 10a428 10a41a: b8 04 00 00 00 mov $0x4,%eax break; } return RTEMS_INVALID_ID; } 10a41f: 8d 65 f8 lea -0x8(%ebp),%esp 10a422: 5b pop %ebx 10a423: 5e pop %esi 10a424: c9 leave 10a425: c3 ret 10a426: 66 90 xchg %ax,%ax the_semaphore = _Semaphore_Get_interrupt_disable( id, &location, &level ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10a428: f6 40 10 30 testb $0x30,0x10(%eax) 10a42c: 74 3a je 10a468 _CORE_mutex_Seize( 10a42e: 83 ec 0c sub $0xc,%esp 10a431: ff 75 f0 pushl -0x10(%ebp) 10a434: ff 75 10 pushl 0x10(%ebp) 10a437: 83 75 0c 01 xorl $0x1,0xc(%ebp) 10a43b: 83 65 0c 01 andl $0x1,0xc(%ebp) 10a43f: ff 75 0c pushl 0xc(%ebp) 10a442: 53 push %ebx 10a443: 8d 40 14 lea 0x14(%eax),%eax 10a446: 50 push %eax 10a447: e8 b0 0b 00 00 call 10affc <_CORE_mutex_Seize> id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, level ); return _Semaphore_Translate_core_mutex_return_code( 10a44c: 83 c4 14 add $0x14,%esp 10a44f: a1 1c e7 11 00 mov 0x11e71c,%eax 10a454: ff 70 34 pushl 0x34(%eax) 10a457: e8 0c 01 00 00 call 10a568 <_Semaphore_Translate_core_mutex_return_code> 10a45c: 83 c4 10 add $0x10,%esp break; } return RTEMS_INVALID_ID; } 10a45f: 8d 65 f8 lea -0x8(%ebp),%esp 10a462: 5b pop %ebx 10a463: 5e pop %esi 10a464: c9 leave 10a465: c3 ret 10a466: 66 90 xchg %ax,%ax /** * 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 10a468: 8b 75 f0 mov -0x10(%ebp),%esi * @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( 10a46b: 8b 0d 1c e7 11 00 mov 0x11e71c,%ecx Heap_Control *the_heap, 10a471: c7 41 34 00 00 00 00 movl $0x0,0x34(%ecx) size_t size 10a478: 8b 40 5c mov 0x5c(%eax),%eax 10a47b: 85 c0 test %eax,%eax 10a47d: 75 29 jne 10a4a8 ); /** * 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. 10a47f: f6 45 0c 01 testb $0x1,0xc(%ebp) 10a483: 74 2b je 10a4b0 * Any other value of @a alignment is taken "as is", i.e., even odd 10a485: 56 push %esi 10a486: 9d popf * alignments are possible. 10a487: c7 41 34 01 00 00 00 movl $0x1,0x34(%ecx) id, ((_Options_Is_no_wait( option_set )) ? FALSE : TRUE), timeout, &level ); return _Semaphore_Translate_core_semaphore_return_code( 10a48e: 83 ec 0c sub $0xc,%esp 10a491: a1 1c e7 11 00 mov 0x11e71c,%eax 10a496: ff 70 34 pushl 0x34(%eax) 10a499: e8 da 00 00 00 call 10a578 <_Semaphore_Translate_core_semaphore_return_code> 10a49e: 83 c4 10 add $0x10,%esp break; } return RTEMS_INVALID_ID; } 10a4a1: 8d 65 f8 lea -0x8(%ebp),%esp 10a4a4: 5b pop %ebx 10a4a5: 5e pop %esi 10a4a6: c9 leave 10a4a7: c3 ret * @return NULL if unsuccessful and a pointer to the block if successful */ void *_Protected_heap_Allocate( Heap_Control *the_heap, size_t size ); 10a4a8: 48 dec %eax 10a4a9: 89 42 5c mov %eax,0x5c(%edx) 10a4ac: 56 push %esi 10a4ad: 9d popf 10a4ae: eb de jmp 10a48e /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10a4b0: a1 58 e6 11 00 mov 0x11e658,%eax 10a4b5: 40 inc %eax 10a4b6: a3 58 e6 11 00 mov %eax,0x11e658 { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } /** * This routine grows @a the_heap memory area using the size bytes which 10a4bb: c7 42 44 01 00 00 00 movl $0x1,0x44(%edx) * 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 10a4c2: 8d 42 14 lea 0x14(%edx),%eax 10a4c5: 89 41 44 mov %eax,0x44(%ecx) * @return NULL if unsuccessful and a pointer to the block if successful 10a4c8: 89 59 20 mov %ebx,0x20(%ecx) */ 10a4cb: 56 push %esi 10a4cc: 9d popf void *_Protected_heap_Allocate_aligned( Heap_Control *the_heap, 10a4cd: 52 push %edx 10a4ce: 68 fc ca 10 00 push $0x10cafc 10a4d3: ff 75 10 pushl 0x10(%ebp) 10a4d6: 50 push %eax 10a4d7: e8 d0 22 00 00 call 10c7ac <_Thread_queue_Enqueue_with_handler> size_t size, 10a4dc: e8 0b 1e 00 00 call 10c2ec <_Thread_Enable_dispatch> 10a4e1: 83 c4 10 add $0x10,%esp 10a4e4: eb a8 jmp 10a48e =============================================================================== 0010a4e8 : #endif rtems_status_code rtems_semaphore_release( rtems_id id ) { 10a4e8: 55 push %ebp 10a4e9: 89 e5 mov %esp,%ebp 10a4eb: 53 push %ebx 10a4ec: 83 ec 18 sub $0x18,%esp 10a4ef: 8b 5d 08 mov 0x8(%ebp),%ebx * 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 10a4f2: 8d 45 f8 lea -0x8(%ebp),%eax 10a4f5: 50 push %eax 10a4f6: 53 push %ebx 10a4f7: 68 a0 e5 11 00 push $0x11e5a0 10a4fc: e8 a7 15 00 00 call 10baa8 <_Objects_Get> Objects_Locations location; CORE_mutex_Status mutex_status; CORE_semaphore_Status semaphore_status; the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { 10a501: 83 c4 10 add $0x10,%esp 10a504: 8b 55 f8 mov -0x8(%ebp),%edx 10a507: 85 d2 test %edx,%edx 10a509: 74 0d je 10a518 10a50b: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a510: 8b 5d fc mov -0x4(%ebp),%ebx 10a513: c9 leave 10a514: c3 ret 10a515: 8d 76 00 lea 0x0(%esi),%esi the_semaphore = _Semaphore_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Attributes_Is_counting_semaphore(the_semaphore->attribute_set) ) { 10a518: f6 40 10 30 testb $0x30,0x10(%eax) 10a51c: 75 26 jne 10a544 MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); return _Semaphore_Translate_core_mutex_return_code( mutex_status ); } else { semaphore_status = _CORE_semaphore_Surrender( 10a51e: 52 push %edx 10a51f: 6a 00 push $0x0 10a521: 53 push %ebx 10a522: 83 c0 14 add $0x14,%eax 10a525: 50 push %eax 10a526: e8 d1 0c 00 00 call 10b1fc <_CORE_semaphore_Surrender> 10a52b: 89 c3 mov %eax,%ebx &the_semaphore->Core_control.semaphore, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 10a52d: e8 ba 1d 00 00 call 10c2ec <_Thread_Enable_dispatch> return 10a532: 89 1c 24 mov %ebx,(%esp) 10a535: e8 3e 00 00 00 call 10a578 <_Semaphore_Translate_core_semaphore_return_code> 10a53a: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a53d: 8b 5d fc mov -0x4(%ebp),%ebx 10a540: c9 leave 10a541: c3 ret 10a542: 66 90 xchg %ax,%ax 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( 10a544: 51 push %ecx 10a545: 6a 00 push $0x0 10a547: 53 push %ebx 10a548: 83 c0 14 add $0x14,%eax 10a54b: 50 push %eax 10a54c: e8 47 0b 00 00 call 10b098 <_CORE_mutex_Surrender> 10a551: 89 c3 mov %eax,%ebx &the_semaphore->Core_control.mutex, id, MUTEX_MP_SUPPORT ); _Thread_Enable_dispatch(); 10a553: e8 94 1d 00 00 call 10c2ec <_Thread_Enable_dispatch> return _Semaphore_Translate_core_mutex_return_code( mutex_status ); 10a558: 89 1c 24 mov %ebx,(%esp) 10a55b: e8 08 00 00 00 call 10a568 <_Semaphore_Translate_core_mutex_return_code> 10a560: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a563: 8b 5d fc mov -0x4(%ebp),%ebx 10a566: c9 leave 10a567: c3 ret =============================================================================== 00116888 : */ void rtems_shutdown_executive( uint32_t result ) { 116888: 55 push %ebp 116889: 89 e5 mov %esp,%ebp 11688b: 83 ec 28 sub $0x28,%esp if ( _System_state_Current != SYSTEM_STATE_SHUTDOWN ) { 11688e: 83 3d 24 e8 11 00 04 cmpl $0x4,0x11e824 116895: 74 1e je 1168b5 <== NEVER TAKEN RTEMS_INLINE_ROUTINE void _System_state_Set ( System_state_Codes state ) { _System_state_Current = state; 116897: c7 05 24 e8 11 00 04 movl $0x4,0x11e824 11689e: 00 00 00 #endif } /** * This routine sets the current system state to that specified by * the called. 1168a1: 83 ec 08 sub $0x8,%esp 1168a4: 68 40 e6 11 00 push $0x11e640 1168a9: 8d 45 e8 lea -0x18(%ebp),%eax 1168ac: 50 push %eax 1168ad: e8 0e 6c ff ff call 10d4c0 <_CPU_Context_switch> 1168b2: 83 c4 10 add $0x10,%esp <== NOT EXECUTED _System_state_Set( SYSTEM_STATE_SHUTDOWN ); _Thread_Stop_multitasking(); } } 1168b5: c9 leave <== NOT EXECUTED 1168b6: c3 ret <== NOT EXECUTED =============================================================================== 0010b224 : rtems_status_code rtems_signal_catch( rtems_asr_entry asr_handler, rtems_mode mode_set ) { 10b224: 55 push %ebp 10b225: 89 e5 mov %esp,%ebp 10b227: 83 ec 08 sub $0x8,%esp 10b22a: 8b 4d 08 mov 0x8(%ebp),%ecx RTEMS_API_Control *api; ASR_Information *asr; /* XXX normalize mode */ executing = _Thread_Executing; api = (RTEMS_API_Control*)executing->API_Extensions[ THREAD_API_RTEMS ]; 10b22d: a1 9c 17 12 00 mov 0x12179c,%eax 10b232: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10b238: a1 d8 16 12 00 mov 0x1216d8,%eax 10b23d: 40 inc %eax 10b23e: a3 d8 16 12 00 mov %eax,0x1216d8 asr = &api->Signal; _Thread_Disable_dispatch(); /* cannot reschedule while */ /* the thread is inconsistent */ if ( !_ASR_Is_null_handler( asr_handler ) ) { 10b243: 85 c9 test %ecx,%ecx 10b245: 74 15 je 10b25c <== NEVER TAKEN asr->mode_set = mode_set; 10b247: 8b 45 0c mov 0xc(%ebp),%eax 10b24a: 89 42 10 mov %eax,0x10(%edx) asr->handler = asr_handler; 10b24d: 89 4a 0c mov %ecx,0xc(%edx) } else _ASR_Initialize( asr ); _Thread_Enable_dispatch(); 10b250: e8 0b 21 00 00 call 10d360 <_Thread_Enable_dispatch> return RTEMS_SUCCESSFUL; } 10b255: 31 c0 xor %eax,%eax 10b257: c9 leave 10b258: c3 ret 10b259: 8d 76 00 lea 0x0(%esi),%esi #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 10b25c: 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 10b260: 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. 10b267: c7 42 10 00 00 00 00 movl $0x0,0x10(%edx) <== NOT EXECUTED * 10b26e: c7 42 14 00 00 00 00 movl $0x0,0x14(%edx) <== NOT EXECUTED * @param[in] the_heap is the heap to operate upon 10b275: 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 10b27c: 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(); 10b283: e8 d8 20 00 00 call 10d360 <_Thread_Enable_dispatch><== NOT EXECUTED return RTEMS_SUCCESSFUL; } 10b288: 31 c0 xor %eax,%eax <== NOT EXECUTED 10b28a: c9 leave <== NOT EXECUTED 10b28b: c3 ret <== NOT EXECUTED =============================================================================== 00113c80 : rtems_status_code rtems_signal_send( Objects_Id id, rtems_signal_set signal_set ) { 113c80: 55 push %ebp 113c81: 89 e5 mov %esp,%ebp 113c83: 53 push %ebx 113c84: 83 ec 14 sub $0x14,%esp 113c87: 8b 5d 0c mov 0xc(%ebp),%ebx register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; ASR_Information *asr; if ( !signal_set ) 113c8a: 85 db test %ebx,%ebx 113c8c: 75 0a jne 113c98 <== ALWAYS TAKEN 113c8e: b8 0a 00 00 00 mov $0xa,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 113c93: 8b 5d fc mov -0x4(%ebp),%ebx 113c96: c9 leave 113c97: c3 ret ASR_Information *asr; if ( !signal_set ) return RTEMS_INVALID_NUMBER; the_thread = _Thread_Get( id, &location ); 113c98: 83 ec 08 sub $0x8,%esp 113c9b: 8d 45 f8 lea -0x8(%ebp),%eax 113c9e: 50 push %eax 113c9f: ff 75 08 pushl 0x8(%ebp) 113ca2: e8 a1 37 00 00 call 117448 <_Thread_Get> 113ca7: 89 c1 mov %eax,%ecx switch ( location ) { 113ca9: 83 c4 10 add $0x10,%esp 113cac: 8b 55 f8 mov -0x8(%ebp),%edx 113caf: 85 d2 test %edx,%edx 113cb1: 74 0d je 113cc0 113cb3: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 113cb8: 8b 5d fc mov -0x4(%ebp),%ebx 113cbb: c9 leave 113cbc: c3 ret 113cbd: 8d 76 00 lea 0x0(%esi),%esi the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; 113cc0: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx asr = &api->Signal; if ( ! _ASR_Is_null_handler( asr->handler ) ) { 113cc6: 8b 42 0c mov 0xc(%edx),%eax 113cc9: 85 c0 test %eax,%eax 113ccb: 74 43 je 113d10 if ( asr->is_enabled ) { 113ccd: 80 7a 08 00 cmpb $0x0,0x8(%edx) 113cd1: 74 29 je 113cfc <== NEVER TAKEN * @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 113cd3: 9c pushf 113cd4: fa cli 113cd5: 58 pop %eax ); 113cd6: 09 5a 14 or %ebx,0x14(%edx) 113cd9: 50 push %eax 113cda: 9d popf _ASR_Post_signals( signal_set, &asr->signals_posted ); the_thread->do_post_task_switch_extension = true; 113cdb: c6 41 75 01 movb $0x1,0x75(%ecx) if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) ) 113cdf: a1 d8 5a 13 00 mov 0x135ad8,%eax 113ce4: 85 c0 test %eax,%eax 113ce6: 74 1c je 113d04 113ce8: 3b 0d fc 5a 13 00 cmp 0x135afc,%ecx 113cee: 75 14 jne 113d04 <== NEVER TAKEN _ISR_Signals_to_thread_executing = TRUE; 113cf0: c6 05 a8 5b 13 00 01 movb $0x1,0x135ba8 113cf7: eb 0b jmp 113d04 113cf9: 8d 76 00 lea 0x0(%esi),%esi * @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 113cfc: 9c pushf <== NOT EXECUTED 113cfd: fa cli <== NOT EXECUTED 113cfe: 58 pop %eax <== NOT EXECUTED ); 113cff: 09 5a 18 or %ebx,0x18(%edx) <== NOT EXECUTED 113d02: 50 push %eax <== NOT EXECUTED 113d03: 9d popf <== NOT EXECUTED } else { _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); 113d04: e8 1b 37 00 00 call 117424 <_Thread_Enable_dispatch> 113d09: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 113d0b: 8b 5d fc mov -0x4(%ebp),%ebx 113d0e: c9 leave 113d0f: c3 ret _ASR_Post_signals( signal_set, &asr->signals_pending ); } _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 113d10: e8 0f 37 00 00 call 117424 <_Thread_Enable_dispatch> 113d15: b8 0b 00 00 00 mov $0xb,%eax 113d1a: e9 74 ff ff ff jmp 113c93 =============================================================================== 00107318 : * rtems_stack_checker_Begin_extension */ void rtems_stack_checker_begin_extension( Thread_Control *the_thread ) { 107318: 55 push %ebp 107319: 89 e5 mov %esp,%ebp 10731b: 57 push %edi 10731c: 56 push %esi 10731d: 8b 45 08 mov 0x8(%ebp),%eax Stack_check_Control *the_pattern; if ( the_thread->Object.id == 0 ) /* skip system tasks */ 107320: 8b 50 08 mov 0x8(%eax),%edx 107323: 85 d2 test %edx,%edx 107325: 74 15 je 10733c <== NEVER TAKEN return; the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack); *the_pattern = Stack_check_Pattern; 107327: 8b 80 c8 00 00 00 mov 0xc8(%eax),%eax 10732d: 8d 78 08 lea 0x8(%eax),%edi 107330: be 50 15 12 00 mov $0x121550,%esi 107335: b9 04 00 00 00 mov $0x4,%ecx 10733a: f3 a5 rep movsl %ds:(%esi),%es:(%edi) } 10733c: 5e pop %esi 10733d: 5f pop %edi 10733e: c9 leave 10733f: c3 ret =============================================================================== 00107700 : */ bool rtems_stack_checker_create_extension( Thread_Control *running, Thread_Control *the_thread ) { 107700: 55 push %ebp 107701: 89 e5 mov %esp,%ebp 107703: 57 push %edi 107704: 83 ec 04 sub $0x4,%esp 107707: 8b 7d 0c mov 0xc(%ebp),%edi Stack_check_Initialize(); 10770a: e8 81 ff ff ff call 107690 if (the_thread) 10770f: 85 ff test %edi,%edi 107711: 74 10 je 107723 <== NEVER TAKEN Stack_check_Dope_stack(&the_thread->Start.Initial_stack); 107713: 8b 8f c4 00 00 00 mov 0xc4(%edi),%ecx 107719: 8b bf c8 00 00 00 mov 0xc8(%edi),%edi 10771f: b0 a5 mov $0xa5,%al 107721: f3 aa rep stos %al,%es:(%edi) return true; } 107723: b0 01 mov $0x1,%al 107725: 5a pop %edx 107726: 5f pop %edi 107727: c9 leave 107728: c3 ret =============================================================================== 001075a4 : /* * Check if blown */ bool rtems_stack_checker_is_blown( void ) { 1075a4: 55 push %ebp <== NOT EXECUTED 1075a5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1075a7: 57 push %edi <== NOT EXECUTED 1075a8: 56 push %esi <== NOT EXECUTED 1075a9: 53 push %ebx <== NOT EXECUTED 1075aa: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack; 1075ad: a1 bc 17 12 00 mov 0x1217bc,%eax <== NOT EXECUTED ) { void *sp = __builtin_frame_address(0); #if defined(__GNUC__) if ( sp < the_stack->area ) { 1075b2: 8b 90 c8 00 00 00 mov 0xc8(%eax),%edx <== NOT EXECUTED 1075b8: 39 d5 cmp %edx,%ebp <== NOT EXECUTED 1075ba: 73 38 jae 1075f4 <== NOT EXECUTED 1075bc: 31 db xor %ebx,%ebx <== NOT EXECUTED /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 1075be: 8b 35 10 13 12 00 mov 0x121310,%esi <== NOT EXECUTED 1075c4: 85 f6 test %esi,%esi <== NOT EXECUTED 1075c6: 75 44 jne 10760c <== NOT EXECUTED 1075c8: b0 01 mov $0x1,%al <== NOT EXECUTED } /* * The Stack Pointer and the Pattern Area are OK so return false. */ if ( sp_ok && pattern_ok ) 1075ca: 84 db test %bl,%bl <== NOT EXECUTED 1075cc: 74 04 je 1075d2 <== NOT EXECUTED 1075ce: 84 c0 test %al,%al <== NOT EXECUTED 1075d0: 75 4e jne 107620 <== NOT EXECUTED return false; /* * Let's report as much as we can. */ Stack_check_report_blown_task( _Thread_Executing, pattern_ok ); 1075d2: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1075d5: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 1075d8: 50 push %eax <== NOT EXECUTED 1075d9: ff 35 bc 17 12 00 pushl 0x1217bc <== NOT EXECUTED 1075df: e8 54 ff ff ff call 107538 <== NOT EXECUTED 1075e4: b0 01 mov $0x1,%al <== NOT EXECUTED 1075e6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return true; } 1075e9: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1075ec: 5b pop %ebx <== NOT EXECUTED 1075ed: 5e pop %esi <== NOT EXECUTED 1075ee: 5f pop %edi <== NOT EXECUTED 1075ef: c9 leave <== NOT EXECUTED 1075f0: c3 ret <== NOT EXECUTED 1075f1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED ) { void *sp = __builtin_frame_address(0); #if defined(__GNUC__) if ( sp < the_stack->area ) { 1075f4: 8b 88 c4 00 00 00 mov 0xc4(%eax),%ecx <== NOT EXECUTED 1075fa: 8d 04 0a lea (%edx,%ecx,1),%eax <== NOT EXECUTED 1075fd: 39 c5 cmp %eax,%ebp <== NOT EXECUTED 1075ff: 0f 96 c3 setbe %bl <== NOT EXECUTED /* * The stack checker must be initialized before the pattern is there * to check. */ if ( Stack_check_Initialized ) { 107602: 8b 35 10 13 12 00 mov 0x121310,%esi <== NOT EXECUTED 107608: 85 f6 test %esi,%esi <== NOT EXECUTED 10760a: 74 bc je 1075c8 <== NOT EXECUTED pattern_ok = (!memcmp( 10760c: 8d 72 08 lea 0x8(%edx),%esi <== NOT EXECUTED 10760f: bf 50 15 12 00 mov $0x121550,%edi <== NOT EXECUTED 107614: b9 10 00 00 00 mov $0x10,%ecx <== NOT EXECUTED 107619: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 10761b: 0f 94 c0 sete %al <== NOT EXECUTED 10761e: eb aa jmp 1075ca <== NOT EXECUTED } /* * The Stack Pointer and the Pattern Area are OK so return false. */ if ( sp_ok && pattern_ok ) 107620: 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; } 107622: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107625: 5b pop %ebx <== NOT EXECUTED 107626: 5e pop %esi <== NOT EXECUTED 107627: 5f pop %edi <== NOT EXECUTED 107628: c9 leave <== NOT EXECUTED 107629: c3 ret <== NOT EXECUTED =============================================================================== 00107520 : void rtems_stack_checker_report_usage( void ) { 107520: 55 push %ebp <== NOT EXECUTED 107521: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107523: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin ); 107526: 68 90 8a 10 00 push $0x108a90 <== NOT EXECUTED 10752b: 6a 00 push $0x0 <== NOT EXECUTED 10752d: e8 8a ff ff ff call 1074bc <== NOT EXECUTED 107532: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 107535: c9 leave <== NOT EXECUTED 107536: c3 ret <== NOT EXECUTED =============================================================================== 001074bc : void rtems_stack_checker_report_usage_with_plugin( void *context, rtems_printk_plugin_t print ) { 1074bc: 55 push %ebp <== NOT EXECUTED 1074bd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1074bf: 56 push %esi <== NOT EXECUTED 1074c0: 53 push %ebx <== NOT EXECUTED 1074c1: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 1074c4: 8b 75 0c mov 0xc(%ebp),%esi <== NOT EXECUTED print_context = context; 1074c7: 89 1d 14 13 12 00 mov %ebx,0x121314 <== NOT EXECUTED print_handler = print; 1074cd: 89 35 18 13 12 00 mov %esi,0x121318 <== NOT EXECUTED (*print)( context, "Stack usage by thread\n"); 1074d3: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1074d6: 68 23 aa 11 00 push $0x11aa23 <== NOT EXECUTED 1074db: 53 push %ebx <== NOT EXECUTED 1074dc: ff d6 call *%esi <== NOT EXECUTED (*print)( context, 1074de: 58 pop %eax <== NOT EXECUTED 1074df: 5a pop %edx <== NOT EXECUTED 1074e0: 68 3c aa 11 00 push $0x11aa3c <== NOT EXECUTED 1074e5: 53 push %ebx <== NOT EXECUTED 1074e6: 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 ); 1074e8: c7 04 24 7c 73 10 00 movl $0x10737c,(%esp) <== NOT EXECUTED 1074ef: e8 44 4f 00 00 call 10c438 <== NOT EXECUTED /* dump interrupt stack info if any */ Stack_check_Dump_threads_usage((Thread_Control *) -1); 1074f4: c7 04 24 ff ff ff ff movl $0xffffffff,(%esp) <== NOT EXECUTED 1074fb: e8 7c fe ff ff call 10737c <== NOT EXECUTED print_context = NULL; 107500: c7 05 14 13 12 00 00 movl $0x0,0x121314 <== NOT EXECUTED 107507: 00 00 00 print_handler = NULL; 10750a: c7 05 18 13 12 00 00 movl $0x0,0x121318 <== NOT EXECUTED 107511: 00 00 00 107514: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 107517: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10751a: 5b pop %ebx <== NOT EXECUTED 10751b: 5e pop %esi <== NOT EXECUTED 10751c: c9 leave <== NOT EXECUTED 10751d: c3 ret <== NOT EXECUTED =============================================================================== 0010762c : */ void rtems_stack_checker_switch_extension( Thread_Control *running, Thread_Control *heir ) { 10762c: 55 push %ebp 10762d: 89 e5 mov %esp,%ebp 10762f: 57 push %edi 107630: 56 push %esi 107631: 53 push %ebx 107632: 83 ec 08 sub $0x8,%esp 107635: 8b 5d 08 mov 0x8(%ebp),%ebx 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; 107638: 8b 83 c8 00 00 00 mov 0xc8(%ebx),%eax 10763e: 8d 70 08 lea 0x8(%eax),%esi ) { void *sp = __builtin_frame_address(0); #if defined(__GNUC__) if ( sp < the_stack->area ) { 107641: 39 c5 cmp %eax,%ebp 107643: 72 0a jb 10764f <== NEVER TAKEN return false; } if ( sp > (the_stack->area + the_stack->size) ) { 107645: 03 83 c4 00 00 00 add 0xc4(%ebx),%eax 10764b: 39 c5 cmp %eax,%ebp 10764d: 76 25 jbe 107674 <== ALWAYS TAKEN /* * 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, 10764f: bf 50 15 12 00 mov $0x121550,%edi <== NOT EXECUTED 107654: b9 10 00 00 00 mov $0x10,%ecx <== NOT EXECUTED 107659: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) <== NOT EXECUTED 10765b: 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 ); 10765e: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 107661: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 107664: 89 5d 08 mov %ebx,0x8(%ebp) <== NOT EXECUTED } } 107667: 83 c4 08 add $0x8,%esp <== NOT EXECUTED 10766a: 5b pop %ebx <== NOT EXECUTED 10766b: 5e pop %esi <== NOT EXECUTED 10766c: 5f pop %edi <== NOT EXECUTED 10766d: 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 ); 10766e: e9 c5 fe ff ff jmp 107538 <== NOT EXECUTED 107673: 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, 107674: bf 50 15 12 00 mov $0x121550,%edi 107679: b9 10 00 00 00 mov $0x10,%ecx (void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES)); if ( !sp_ok || !pattern_ok ) { 10767e: f3 a6 repz cmpsb %es:(%edi),%ds:(%esi) 107680: 74 06 je 107688 <== ALWAYS TAKEN 107682: 31 c0 xor %eax,%eax 107684: eb d8 jmp 10765e <== NOT EXECUTED 107686: 66 90 xchg %ax,%ax <== NOT EXECUTED Stack_check_report_blown_task( running, pattern_ok ); } } 107688: 83 c4 08 add $0x8,%esp 10768b: 5b pop %ebx 10768c: 5e pop %esi 10768d: 5f pop %edi 10768e: c9 leave 10768f: c3 ret =============================================================================== 00107afc : const char * rtems_status_text( rtems_status_code status ) { 107afc: 55 push %ebp <== NOT EXECUTED 107afd: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107aff: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED return rtems_assoc_name_by_local(rtems_status_assoc, status); 107b02: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 107b05: 68 40 b5 11 00 push $0x11b540 <== NOT EXECUTED 107b0a: e8 e9 80 00 00 call 10fbf8 <== NOT EXECUTED } 107b0f: c9 leave <== NOT EXECUTED 107b10: c3 ret <== NOT EXECUTED =============================================================================== 0010a588 : size_t stack_size, rtems_mode initial_modes, rtems_attribute attribute_set, Objects_Id *id ) { 10a588: 55 push %ebp 10a589: 89 e5 mov %esp,%ebp 10a58b: 57 push %edi 10a58c: 56 push %esi 10a58d: 53 push %ebx 10a58e: 83 ec 0c sub $0xc,%esp 10a591: 8b 7d 08 mov 0x8(%ebp),%edi 10a594: 8b 5d 18 mov 0x18(%ebp),%ebx Priority_Control core_priority; RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) 10a597: 8b 45 1c mov 0x1c(%ebp),%eax 10a59a: 85 c0 test %eax,%eax 10a59c: 0f 84 32 01 00 00 je 10a6d4 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10a5a2: 85 ff test %edi,%edi 10a5a4: 0f 84 c2 00 00 00 je 10a66c /* * Validate the RTEMS API priority and convert it to the core priority range. */ if ( !_Attributes_Is_system_task( the_attribute_set ) ) { 10a5aa: 66 85 db test %bx,%bx 10a5ad: 78 1b js 10a5ca bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ); 10a5af: 8b 45 0c mov 0xc(%ebp),%eax 10a5b2: 85 c0 test %eax,%eax 10a5b4: 0f 84 f2 00 00 00 je 10a6ac 10a5ba: 0f b6 05 14 a1 11 00 movzbl 0x11a114,%eax 10a5c1: 39 45 0c cmp %eax,0xc(%ebp) 10a5c4: 0f 87 e2 00 00 00 ja 10a6ac <== NEVER TAKEN */ /* * Lock the allocator mutex for protection */ _RTEMS_Lock_allocator(); 10a5ca: 83 ec 0c sub $0xc,%esp 10a5cd: ff 35 14 e7 11 00 pushl 0x11e714 10a5d3: e8 30 07 00 00 call 10ad08 <_API_Mutex_Lock> #ifdef __cplusplus extern "C" { #endif /** 10a5d8: c7 04 24 e0 e5 11 00 movl $0x11e5e0,(%esp) 10a5df: e8 d0 0f 00 00 call 10b5b4 <_Objects_Allocate> 10a5e4: 89 c6 mov %eax,%esi * the event of an error. */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { 10a5e6: 83 c4 10 add $0x10,%esp 10a5e9: 85 c0 test %eax,%eax 10a5eb: 0f 84 cb 00 00 00 je 10a6bc /* * Initialize the core thread for this task. */ status = _Thread_Initialize( 10a5f1: 50 push %eax 10a5f2: 57 push %edi 10a5f3: 8b 45 14 mov 0x14(%ebp),%eax 10a5f6: 83 e0 01 and $0x1,%eax 10a5f9: 50 push %eax 10a5fa: 6a 00 push $0x0 10a5fc: 8b 45 14 mov 0x14(%ebp),%eax 10a5ff: c1 e8 09 shr $0x9,%eax 10a602: 83 e0 01 and $0x1,%eax 10a605: 50 push %eax 10a606: 8b 45 14 mov 0x14(%ebp),%eax 10a609: c1 e8 08 shr $0x8,%eax 10a60c: 83 f0 01 xor $0x1,%eax 10a60f: 83 e0 01 and $0x1,%eax 10a612: 50 push %eax 10a613: ff 75 0c pushl 0xc(%ebp) 10a616: 83 e3 01 and $0x1,%ebx 10a619: 53 push %ebx 10a61a: ff 75 10 pushl 0x10(%ebp) 10a61d: 6a 00 push $0x0 10a61f: 56 push %esi 10a620: 68 e0 e5 11 00 push $0x11e5e0 10a625: e8 66 1d 00 00 call 10c390 <_Thread_Initialize> NULL, /* no budget algorithm callout */ _Modes_Get_interrupt_level(initial_modes), (Objects_Name) name ); if ( !status ) { 10a62a: 83 c4 30 add $0x30,%esp 10a62d: 84 c0 test %al,%al 10a62f: 74 4b je 10a67c } api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; asr = &api->Signal; asr->is_enabled = _Modes_Is_asr_disabled(initial_modes) ? false : true; 10a631: 8b 86 f4 00 00 00 mov 0xf4(%esi),%eax 10a637: c1 6d 14 0a shrl $0xa,0x14(%ebp) 10a63b: 83 75 14 01 xorl $0x1,0x14(%ebp) 10a63f: 8a 55 14 mov 0x14(%ebp),%dl 10a642: 83 e2 01 and $0x1,%edx 10a645: 88 50 08 mov %dl,0x8(%eax) *id = the_thread->Object.id; 10a648: 8b 46 08 mov 0x8(%esi),%eax 10a64b: 8b 55 1c mov 0x1c(%ebp),%edx 10a64e: 89 02 mov %eax,(%edx) ); } #endif _RTEMS_Unlock_allocator(); 10a650: 83 ec 0c sub $0xc,%esp 10a653: ff 35 14 e7 11 00 pushl 0x11e714 10a659: e8 f2 06 00 00 call 10ad50 <_API_Mutex_Unlock> 10a65e: 31 c0 xor %eax,%eax 10a660: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; } 10a663: 8d 65 f4 lea -0xc(%ebp),%esp 10a666: 5b pop %ebx 10a667: 5e pop %esi 10a668: 5f pop %edi 10a669: c9 leave 10a66a: c3 ret 10a66b: 90 nop if ( !id ) return RTEMS_INVALID_ADDRESS; if ( !rtems_is_name_valid( name ) ) 10a66c: b8 03 00 00 00 mov $0x3,%eax } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10a671: 8d 65 f4 lea -0xc(%ebp),%esp 10a674: 5b pop %ebx 10a675: 5e pop %esi 10a676: 5f pop %edi 10a677: c9 leave 10a678: c3 ret 10a679: 8d 76 00 lea 0x0(%esi),%esi * @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 10a67c: 83 ec 0c sub $0xc,%esp 10a67f: ff 76 08 pushl 0x8(%esi) 10a682: e8 61 13 00 00 call 10b9e8 <_Objects_Get_information_id> 10a687: 5a pop %edx 10a688: 59 pop %ecx 10a689: 56 push %esi 10a68a: 50 push %eax 10a68b: e8 e4 12 00 00 call 10b974 <_Objects_Free> #if defined(RTEMS_MULTIPROCESSING) if ( is_global ) _Objects_MP_Free_global_object( the_global_object ); #endif _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 10a690: 58 pop %eax 10a691: ff 35 14 e7 11 00 pushl 0x11e714 10a697: e8 b4 06 00 00 call 10ad50 <_API_Mutex_Unlock> 10a69c: b8 0d 00 00 00 mov $0xd,%eax 10a6a1: 83 c4 10 add $0x10,%esp } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; } 10a6a4: 8d 65 f4 lea -0xc(%ebp),%esp 10a6a7: 5b pop %ebx 10a6a8: 5e pop %esi 10a6a9: 5f pop %edi 10a6aa: c9 leave 10a6ab: c3 ret } #endif _RTEMS_Unlock_allocator(); return RTEMS_SUCCESSFUL; 10a6ac: b8 13 00 00 00 mov $0x13,%eax } 10a6b1: 8d 65 f4 lea -0xc(%ebp),%esp 10a6b4: 5b pop %ebx 10a6b5: 5e pop %esi 10a6b6: 5f pop %edi 10a6b7: c9 leave 10a6b8: c3 ret 10a6b9: 8d 76 00 lea 0x0(%esi),%esi */ the_thread = _RTEMS_tasks_Allocate(); if ( !the_thread ) { _RTEMS_Unlock_allocator(); 10a6bc: 83 ec 0c sub $0xc,%esp 10a6bf: ff 35 14 e7 11 00 pushl 0x11e714 10a6c5: e8 86 06 00 00 call 10ad50 <_API_Mutex_Unlock> 10a6ca: b8 05 00 00 00 mov $0x5,%eax 10a6cf: 83 c4 10 add $0x10,%esp 10a6d2: eb 9d jmp 10a671 Priority_Control core_priority; RTEMS_API_Control *api; ASR_Information *asr; if ( !id ) 10a6d4: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 10a6d9: eb 96 jmp 10a671 <== NOT EXECUTED =============================================================================== 0010a6dc : */ rtems_status_code rtems_task_delete( Objects_Id id ) { 10a6dc: 55 push %ebp 10a6dd: 89 e5 mov %esp,%ebp 10a6df: 53 push %ebx 10a6e0: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; Objects_Information *the_information; _RTEMS_Lock_allocator(); 10a6e3: ff 35 14 e7 11 00 pushl 0x11e714 10a6e9: e8 1a 06 00 00 call 10ad08 <_API_Mutex_Lock> the_thread = _Thread_Get( id, &location ); 10a6ee: 58 pop %eax 10a6ef: 5a pop %edx 10a6f0: 8d 45 f8 lea -0x8(%ebp),%eax 10a6f3: 50 push %eax 10a6f4: ff 75 08 pushl 0x8(%ebp) 10a6f7: e8 14 1c 00 00 call 10c310 <_Thread_Get> 10a6fc: 89 c3 mov %eax,%ebx switch ( location ) { 10a6fe: 83 c4 10 add $0x10,%esp 10a701: 8b 45 f8 mov -0x8(%ebp),%eax 10a704: 85 c0 test %eax,%eax 10a706: 75 44 jne 10a74c case OBJECTS_LOCAL: the_information = _Objects_Get_information_id( the_thread->Object.id ); 10a708: 83 ec 0c sub $0xc,%esp 10a70b: ff 73 08 pushl 0x8(%ebx) 10a70e: e8 d5 12 00 00 call 10b9e8 <_Objects_Get_information_id> 0 /* Not used */ ); } #endif _Thread_Close( the_information, the_thread ); 10a713: 5a pop %edx 10a714: 59 pop %ecx 10a715: 53 push %ebx 10a716: 50 push %eax 10a717: e8 b4 18 00 00 call 10bfd0 <_Thread_Close> 10a71c: 58 pop %eax 10a71d: ff 73 08 pushl 0x8(%ebx) 10a720: e8 c3 12 00 00 call 10b9e8 <_Objects_Get_information_id> 10a725: 5a pop %edx 10a726: 59 pop %ecx 10a727: 53 push %ebx 10a728: 50 push %eax 10a729: e8 46 12 00 00 call 10b974 <_Objects_Free> _RTEMS_tasks_Free( the_thread ); _RTEMS_Unlock_allocator(); 10a72e: 58 pop %eax 10a72f: ff 35 14 e7 11 00 pushl 0x11e714 10a735: e8 16 06 00 00 call 10ad50 <_API_Mutex_Unlock> _Thread_Enable_dispatch(); 10a73a: e8 ad 1b 00 00 call 10c2ec <_Thread_Enable_dispatch> 10a73f: 31 c0 xor %eax,%eax 10a741: 83 c4 10 add $0x10,%esp break; } _RTEMS_Unlock_allocator(); return RTEMS_INVALID_ID; } 10a744: 8b 5d fc mov -0x4(%ebp),%ebx 10a747: c9 leave 10a748: c3 ret 10a749: 8d 76 00 lea 0x0(%esi),%esi case OBJECTS_ERROR: break; } _RTEMS_Unlock_allocator(); 10a74c: 83 ec 0c sub $0xc,%esp 10a74f: ff 35 14 e7 11 00 pushl 0x11e714 10a755: e8 f6 05 00 00 call 10ad50 <_API_Mutex_Unlock> 10a75a: b8 04 00 00 00 mov $0x4,%eax 10a75f: 83 c4 10 add $0x10,%esp return RTEMS_INVALID_ID; } 10a762: 8b 5d fc mov -0x4(%ebp),%ebx 10a765: c9 leave 10a766: c3 ret =============================================================================== 0010be34 : rtems_status_code rtems_task_get_note( Objects_Id id, uint32_t notepad, uint32_t *note ) { 10be34: 55 push %ebp 10be35: 89 e5 mov %esp,%ebp 10be37: 83 ec 18 sub $0x18,%esp register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10be3a: a1 34 3a 12 00 mov 0x123a34,%eax 10be3f: 8b 40 40 mov 0x40(%eax),%eax 10be42: 80 78 04 00 cmpb $0x0,0x4(%eax) 10be46: 74 64 je 10beac <== NEVER TAKEN return RTEMS_NOT_CONFIGURED; if ( !note ) 10be48: 8b 45 10 mov 0x10(%ebp),%eax 10be4b: 85 c0 test %eax,%eax 10be4d: 0f 84 85 00 00 00 je 10bed8 <== NEVER TAKEN /* * 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 ) 10be53: 83 7d 0c 0f cmpl $0xf,0xc(%ebp) 10be57: 77 4b ja 10bea4 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10be59: 8b 4d 08 mov 0x8(%ebp),%ecx 10be5c: 85 c9 test %ecx,%ecx 10be5e: 74 54 je 10beb4 10be60: a1 5c 3a 12 00 mov 0x123a5c,%eax 10be65: 8b 55 08 mov 0x8(%ebp),%edx 10be68: 3b 50 08 cmp 0x8(%eax),%edx 10be6b: 74 4c je 10beb9 api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10be6d: 83 ec 08 sub $0x8,%esp 10be70: 8d 45 fc lea -0x4(%ebp),%eax 10be73: 50 push %eax 10be74: ff 75 08 pushl 0x8(%ebp) 10be77: e8 e8 1e 00 00 call 10dd64 <_Thread_Get> switch ( location ) { 10be7c: 83 c4 10 add $0x10,%esp 10be7f: 8b 55 fc mov -0x4(%ebp),%edx 10be82: 85 d2 test %edx,%edx 10be84: 75 4a jne 10bed0 <== ALWAYS TAKEN case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; *note = api->Notepads[ notepad ]; 10be86: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax <== NOT EXECUTED 10be8c: 8b 55 0c mov 0xc(%ebp),%edx <== NOT EXECUTED 10be8f: 8b 44 90 20 mov 0x20(%eax,%edx,4),%eax <== NOT EXECUTED 10be93: 8b 55 10 mov 0x10(%ebp),%edx <== NOT EXECUTED 10be96: 89 02 mov %eax,(%edx) <== NOT EXECUTED _Thread_Enable_dispatch(); 10be98: e8 a3 1e 00 00 call 10dd40 <_Thread_Enable_dispatch><== NOT EXECUTED 10be9d: 31 c0 xor %eax,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be9f: c9 leave <== NOT EXECUTED 10bea0: c3 ret <== NOT EXECUTED 10bea1: 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 ) 10bea4: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bea9: c9 leave 10beaa: c3 ret 10beab: 90 nop { register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10beac: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10beb1: c9 leave <== NOT EXECUTED 10beb2: c3 ret <== NOT EXECUTED 10beb3: 90 nop <== NOT EXECUTED 10beb4: a1 5c 3a 12 00 mov 0x123a5c,%eax */ 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 ]; 10beb9: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax 10bebf: 8b 55 0c mov 0xc(%ebp),%edx 10bec2: 8b 44 90 20 mov 0x20(%eax,%edx,4),%eax 10bec6: 8b 55 10 mov 0x10(%ebp),%edx 10bec9: 89 02 mov %eax,(%edx) 10becb: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10becd: c9 leave 10bece: c3 ret 10becf: 90 nop *note = api->Notepads[ notepad ]; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 10bed0: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bed5: c9 leave 10bed6: c3 ret 10bed7: 90 nop RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) return RTEMS_NOT_CONFIGURED; if ( !note ) 10bed8: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bedd: c9 leave <== NOT EXECUTED 10bede: c3 ret <== NOT EXECUTED =============================================================================== 0010a768 : rtems_status_code rtems_task_ident( rtems_name name, uint32_t node, Objects_Id *id ) { 10a768: 55 push %ebp 10a769: 89 e5 mov %esp,%ebp 10a76b: 83 ec 08 sub $0x8,%esp 10a76e: 8b 45 08 mov 0x8(%ebp),%eax 10a771: 8b 55 10 mov 0x10(%ebp),%edx Objects_Name_or_id_lookup_errors status; if ( !id ) 10a774: 85 d2 test %edx,%edx 10a776: 74 30 je 10a7a8 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( name == OBJECTS_ID_OF_SELF ) { 10a778: 85 c0 test %eax,%eax 10a77a: 75 10 jne 10a78c *id = _Thread_Executing->Object.id; 10a77c: a1 1c e7 11 00 mov 0x11e71c,%eax 10a781: 8b 40 08 mov 0x8(%eax),%eax 10a784: 89 02 mov %eax,(%edx) 10a786: 31 c0 xor %eax,%eax } status = _Objects_Name_to_id_u32( &_RTEMS_tasks_Information, name, node, id ); return _Status_Object_name_errors_to_status[ status ]; } 10a788: c9 leave 10a789: c3 ret 10a78a: 66 90 xchg %ax,%ax 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 ); 10a78c: 52 push %edx 10a78d: ff 75 0c pushl 0xc(%ebp) 10a790: 50 push %eax 10a791: 68 e0 e5 11 00 push $0x11e5e0 10a796: e8 65 14 00 00 call 10bc00 <_Objects_Name_to_id_u32> return _Status_Object_name_errors_to_status[ status ]; 10a79b: 8b 04 85 6c 86 11 00 mov 0x11866c(,%eax,4),%eax 10a7a2: 83 c4 10 add $0x10,%esp } 10a7a5: c9 leave 10a7a6: c3 ret 10a7a7: 90 nop Objects_Id *id ) { Objects_Name_or_id_lookup_errors status; if ( !id ) 10a7a8: 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 ]; } 10a7ad: c9 leave <== NOT EXECUTED 10a7ae: c3 ret <== NOT EXECUTED =============================================================================== 0010ad1c : */ rtems_status_code rtems_task_is_suspended( Objects_Id id ) { 10ad1c: 55 push %ebp 10ad1d: 89 e5 mov %esp,%ebp 10ad1f: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10ad22: 8d 45 fc lea -0x4(%ebp),%eax 10ad25: 50 push %eax 10ad26: ff 75 08 pushl 0x8(%ebp) 10ad29: e8 ea 1b 00 00 call 10c918 <_Thread_Get> switch ( location ) { 10ad2e: 83 c4 10 add $0x10,%esp 10ad31: 8b 55 fc mov -0x4(%ebp),%edx 10ad34: 85 d2 test %edx,%edx 10ad36: 74 08 je 10ad40 <== ALWAYS TAKEN 10ad38: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ad3d: c9 leave <== NOT EXECUTED 10ad3e: c3 ret <== NOT EXECUTED 10ad3f: 90 nop <== NOT EXECUTED the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 10ad40: f6 40 10 02 testb $0x2,0x10(%eax) 10ad44: 74 0e je 10ad54 _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10ad46: e8 a9 1b 00 00 call 10c8f4 <_Thread_Enable_dispatch> 10ad4b: b8 0f 00 00 00 mov $0xf,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ad50: c9 leave 10ad51: c3 ret 10ad52: 66 90 xchg %ax,%ax the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { _Thread_Enable_dispatch(); 10ad54: e8 9b 1b 00 00 call 10c8f4 <_Thread_Enable_dispatch> 10ad59: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ad5b: c9 leave 10ad5c: c3 ret =============================================================================== 0010fd50 : rtems_status_code rtems_task_mode( rtems_mode mode_set, rtems_mode mask, rtems_mode *previous_mode_set ) { 10fd50: 55 push %ebp 10fd51: 89 e5 mov %esp,%ebp 10fd53: 57 push %edi 10fd54: 56 push %esi 10fd55: 53 push %ebx 10fd56: 83 ec 0c sub $0xc,%esp 10fd59: 8b 7d 08 mov 0x8(%ebp),%edi ASR_Information *asr; bool is_asr_enabled = false; bool needs_asr_dispatching = false; rtems_mode old_mode; if ( !previous_mode_set ) 10fd5c: 8b 4d 10 mov 0x10(%ebp),%ecx 10fd5f: 85 c9 test %ecx,%ecx 10fd61: 0f 84 31 01 00 00 je 10fe98 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; executing = _Thread_Executing; 10fd67: a1 1c e7 11 00 mov 0x11e71c,%eax 10fd6c: 89 45 ec mov %eax,-0x14(%ebp) api = executing->API_Extensions[ THREAD_API_RTEMS ]; 10fd6f: 8b 90 f4 00 00 00 mov 0xf4(%eax),%edx 10fd75: 89 55 f0 mov %edx,-0x10(%ebp) asr = &api->Signal; old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT; 10fd78: 80 78 76 01 cmpb $0x1,0x76(%eax) 10fd7c: 19 f6 sbb %esi,%esi 10fd7e: 81 e6 00 01 00 00 and $0x100,%esi if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE ) 10fd84: 8b 50 7c mov 0x7c(%eax),%edx 10fd87: 85 d2 test %edx,%edx 10fd89: 0f 85 bd 00 00 00 jne 10fe4c old_mode |= RTEMS_NO_TIMESLICE; else old_mode |= RTEMS_TIMESLICE; old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR; 10fd8f: 8b 5d f0 mov -0x10(%ebp),%ebx 10fd92: 80 7b 08 01 cmpb $0x1,0x8(%ebx) 10fd96: 19 db sbb %ebx,%ebx 10fd98: 81 e3 00 04 00 00 and $0x400,%ebx old_mode |= _ISR_Get_level(); 10fd9e: e8 f9 d8 ff ff call 10d69c <_CPU_ISR_Get_level> 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; 10fda3: 09 c3 or %eax,%ebx old_mode |= _ISR_Get_level(); *previous_mode_set = old_mode; 10fda5: 09 f3 or %esi,%ebx 10fda7: 8b 45 10 mov 0x10(%ebp),%eax 10fdaa: 89 18 mov %ebx,(%eax) /* * These are generic thread scheduling characteristics. */ if ( mask & RTEMS_PREEMPT_MASK ) 10fdac: f7 45 0c 00 01 00 00 testl $0x100,0xc(%ebp) 10fdb3: 74 11 je 10fdc6 executing->is_preemptible = _Modes_Is_preempt(mode_set) ? TRUE : FALSE; 10fdb5: 89 f8 mov %edi,%eax 10fdb7: c1 e8 08 shr $0x8,%eax 10fdba: 83 f0 01 xor $0x1,%eax 10fdbd: 83 e0 01 and $0x1,%eax 10fdc0: 8b 55 ec mov -0x14(%ebp),%edx 10fdc3: 88 42 76 mov %al,0x76(%edx) if ( mask & RTEMS_TIMESLICE_MASK ) { 10fdc6: f7 45 0c 00 02 00 00 testl $0x200,0xc(%ebp) 10fdcd: 74 1e je 10fded if ( _Modes_Is_timeslice(mode_set) ) { 10fdcf: f7 c7 00 02 00 00 test $0x200,%edi 10fdd5: 0f 84 81 00 00 00 je 10fe5c executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE; 10fddb: 8b 5d ec mov -0x14(%ebp),%ebx 10fdde: c7 43 7c 01 00 00 00 movl $0x1,0x7c(%ebx) executing->cpu_time_budget = _Thread_Ticks_per_timeslice; 10fde5: a1 24 e6 11 00 mov 0x11e624,%eax 10fdea: 89 43 78 mov %eax,0x78(%ebx) /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 10fded: f6 45 0c 01 testb $0x1,0xc(%ebp) 10fdf1: 74 09 je 10fdfc * 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 10fdf3: f7 c7 01 00 00 00 test $0x1,%edi 10fdf9: 74 5d je 10fe58 10fdfb: fa cli */ is_asr_enabled = FALSE; needs_asr_dispatching = FALSE; if ( mask & RTEMS_ASR_MASK ) { 10fdfc: f7 45 0c 00 04 00 00 testl $0x400,0xc(%ebp) 10fe03: 74 31 je 10fe36 10fe05: c1 ef 0a shr $0xa,%edi 10fe08: 83 f7 01 xor $0x1,%edi 10fe0b: 89 f8 mov %edi,%eax 10fe0d: 83 e0 01 and $0x1,%eax is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true; if ( is_asr_enabled != asr->is_enabled ) { 10fe10: 8b 55 f0 mov -0x10(%ebp),%edx 10fe13: 38 42 08 cmp %al,0x8(%edx) 10fe16: 74 1e je 10fe36 asr->is_enabled = is_asr_enabled; 10fe18: 88 42 08 mov %al,0x8(%edx) uint32_t page_size ) { return _Heap_Initialize( the_heap, starting_address, size, page_size ); } 10fe1b: 9c pushf 10fe1c: fa cli 10fe1d: 59 pop %ecx /** 10fe1e: 8b 5d f0 mov -0x10(%ebp),%ebx 10fe21: 8b 53 18 mov 0x18(%ebx),%edx * This routine grows @a the_heap memory area using the size bytes which 10fe24: 8b 43 14 mov 0x14(%ebx),%eax 10fe27: 89 43 18 mov %eax,0x18(%ebx) * begin at @a starting_address. 10fe2a: 89 53 14 mov %edx,0x14(%ebx) * 10fe2d: 51 push %ecx 10fe2e: 9d popf _ASR_Swap_signals( asr ); if ( _ASR_Are_signals_pending( asr ) ) { 10fe2f: 8b 43 14 mov 0x14(%ebx),%eax 10fe32: 85 c0 test %eax,%eax 10fe34: 75 56 jne 10fe8c <== NEVER TAKEN needs_asr_dispatching = true; executing->do_post_task_switch_extension = true; 10fe36: 31 db xor %ebx,%ebx } } } if ( _System_state_Is_up(_System_state_Current) ) 10fe38: 83 3d 24 e8 11 00 03 cmpl $0x3,0x11e824 10fe3f: 74 2f je 10fe70 <== ALWAYS TAKEN if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) _Thread_Dispatch(); 10fe41: 31 c0 xor %eax,%eax return RTEMS_SUCCESSFUL; } 10fe43: 83 c4 0c add $0xc,%esp 10fe46: 5b pop %ebx 10fe47: 5e pop %esi 10fe48: 5f pop %edi 10fe49: c9 leave 10fe4a: c3 ret 10fe4b: 90 nop 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; 10fe4c: 81 ce 00 02 00 00 or $0x200,%esi 10fe52: e9 38 ff ff ff jmp 10fd8f 10fe57: 90 nop * 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 10fe58: fb sti 10fe59: eb a1 jmp 10fdfc 10fe5b: 90 nop 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; 10fe5c: 8b 45 ec mov -0x14(%ebp),%eax 10fe5f: c7 40 7c 00 00 00 00 movl $0x0,0x7c(%eax) /* * Set the new interrupt level */ if ( mask & RTEMS_INTERRUPT_MASK ) 10fe66: f6 45 0c 01 testb $0x1,0xc(%ebp) 10fe6a: 74 90 je 10fdfc 10fe6c: eb 85 jmp 10fdf3 10fe6e: 66 90 xchg %ax,%ax } } } if ( _System_state_Is_up(_System_state_Current) ) if ( _Thread_Evaluate_mode() || needs_asr_dispatching ) 10fe70: e8 73 01 00 00 call 10ffe8 <_Thread_Evaluate_mode> 10fe75: 84 c0 test %al,%al 10fe77: 75 04 jne 10fe7d 10fe79: 84 db test %bl,%bl 10fe7b: 74 c4 je 10fe41 <== ALWAYS TAKEN _Thread_Dispatch(); 10fe7d: e8 0e c3 ff ff call 10c190 <_Thread_Dispatch> 10fe82: 31 c0 xor %eax,%eax return RTEMS_SUCCESSFUL; } 10fe84: 83 c4 0c add $0xc,%esp 10fe87: 5b pop %ebx 10fe88: 5e pop %esi 10fe89: 5f pop %edi 10fe8a: c9 leave 10fe8b: c3 ret 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; 10fe8c: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10fe8f: c6 40 75 01 movb $0x1,0x75(%eax) <== NOT EXECUTED 10fe93: b3 01 mov $0x1,%bl <== NOT EXECUTED 10fe95: eb a1 jmp 10fe38 <== NOT EXECUTED 10fe97: 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 ) 10fe98: 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; } 10fe9d: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 10fea0: 5b pop %ebx <== NOT EXECUTED 10fea1: 5e pop %esi <== NOT EXECUTED 10fea2: 5f pop %edi <== NOT EXECUTED 10fea3: c9 leave <== NOT EXECUTED 10fea4: c3 ret <== NOT EXECUTED =============================================================================== 0010b974 : */ rtems_status_code rtems_task_resume( Objects_Id id ) { 10b974: 55 push %ebp 10b975: 89 e5 mov %esp,%ebp 10b977: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10b97a: 8d 45 fc lea -0x4(%ebp),%eax 10b97d: 50 push %eax 10b97e: ff 75 08 pushl 0x8(%ebp) 10b981: e8 82 1e 00 00 call 10d808 <_Thread_Get> switch ( location ) { 10b986: 83 c4 10 add $0x10,%esp 10b989: 8b 55 fc mov -0x4(%ebp),%edx 10b98c: 85 d2 test %edx,%edx 10b98e: 74 08 je 10b998 10b990: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b995: c9 leave 10b996: c3 ret 10b997: 90 nop the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { 10b998: f6 40 10 02 testb $0x2,0x10(%eax) 10b99c: 75 0e jne 10b9ac _Thread_Resume( the_thread, TRUE ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10b99e: e8 15 1e 00 00 call 10d7b8 <_Thread_Enable_dispatch> 10b9a3: b8 0e 00 00 00 mov $0xe,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b9a8: c9 leave 10b9a9: c3 ret 10b9aa: 66 90 xchg %ax,%ax the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _States_Is_suspended( the_thread->current_state ) ) { _Thread_Resume( the_thread, TRUE ); 10b9ac: 83 ec 08 sub $0x8,%esp 10b9af: 6a 01 push $0x1 10b9b1: 50 push %eax 10b9b2: e8 75 26 00 00 call 10e02c <_Thread_Resume> _Thread_Enable_dispatch(); 10b9b7: e8 fc 1d 00 00 call 10d7b8 <_Thread_Enable_dispatch> 10b9bc: 31 c0 xor %eax,%eax 10b9be: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b9c1: c9 leave 10b9c2: c3 ret =============================================================================== 0010bfb8 : rtems_status_code rtems_task_set_note( Objects_Id id, uint32_t notepad, uint32_t note ) { 10bfb8: 55 push %ebp 10bfb9: 89 e5 mov %esp,%ebp 10bfbb: 83 ec 18 sub $0x18,%esp register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10bfbe: a1 34 3a 12 00 mov 0x123a34,%eax 10bfc3: 8b 40 40 mov 0x40(%eax),%eax 10bfc6: 80 78 04 00 cmpb $0x0,0x4(%eax) 10bfca: 74 54 je 10c020 <== NEVER TAKEN /* * 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 ) 10bfcc: 83 7d 0c 0f cmpl $0xf,0xc(%ebp) 10bfd0: 77 46 ja 10c018 /* * Optimize the most likely case to avoid the Thread_Dispatch. */ if ( _Objects_Are_ids_equal( id, OBJECTS_ID_OF_SELF ) || 10bfd2: 8b 4d 08 mov 0x8(%ebp),%ecx 10bfd5: 85 c9 test %ecx,%ecx 10bfd7: 74 4f je 10c028 <== NEVER TAKEN 10bfd9: a1 5c 3a 12 00 mov 0x123a5c,%eax 10bfde: 8b 55 08 mov 0x8(%ebp),%edx 10bfe1: 3b 50 08 cmp 0x8(%eax),%edx 10bfe4: 74 47 je 10c02d <== NEVER TAKEN api = _Thread_Executing->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); 10bfe6: 83 ec 08 sub $0x8,%esp 10bfe9: 8d 45 fc lea -0x4(%ebp),%eax 10bfec: 50 push %eax 10bfed: ff 75 08 pushl 0x8(%ebp) 10bff0: e8 6f 1d 00 00 call 10dd64 <_Thread_Get> switch ( location ) { 10bff5: 83 c4 10 add $0x10,%esp 10bff8: 8b 55 fc mov -0x4(%ebp),%edx 10bffb: 85 d2 test %edx,%edx 10bffd: 75 45 jne 10c044 case OBJECTS_LOCAL: api = the_thread->API_Extensions[ THREAD_API_RTEMS ]; api->Notepads[ notepad ] = note; 10bfff: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax 10c005: 8b 55 10 mov 0x10(%ebp),%edx 10c008: 8b 4d 0c mov 0xc(%ebp),%ecx 10c00b: 89 54 88 20 mov %edx,0x20(%eax,%ecx,4) _Thread_Enable_dispatch(); 10c00f: e8 2c 1d 00 00 call 10dd40 <_Thread_Enable_dispatch> 10c014: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c016: c9 leave 10c017: c3 ret /* * 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 ) 10c018: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c01d: c9 leave 10c01e: c3 ret 10c01f: 90 nop { register Thread_Control *the_thread; Objects_Locations location; RTEMS_API_Control *api; if ( !rtems_configuration_get_notepads_enabled() ) 10c020: b8 16 00 00 00 mov $0x16,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c025: c9 leave <== NOT EXECUTED 10c026: c3 ret <== NOT EXECUTED 10c027: 90 nop <== NOT EXECUTED 10c028: a1 5c 3a 12 00 mov 0x123a5c,%eax */ 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; 10c02d: 8b 80 f4 00 00 00 mov 0xf4(%eax),%eax 10c033: 8b 55 10 mov 0x10(%ebp),%edx 10c036: 8b 4d 0c mov 0xc(%ebp),%ecx 10c039: 89 54 88 20 mov %edx,0x20(%eax,%ecx,4) 10c03d: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c03f: c9 leave 10c040: c3 ret 10c041: 8d 76 00 lea 0x0(%esi),%esi api->Notepads[ notepad ] = note; return RTEMS_SUCCESSFUL; } the_thread = _Thread_Get( id, &location ); switch ( location ) { 10c044: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10c049: c9 leave 10c04a: c3 ret =============================================================================== 0010b744 : rtems_status_code rtems_task_set_priority( Objects_Id id, rtems_task_priority new_priority, rtems_task_priority *old_priority ) { 10b744: 55 push %ebp 10b745: 89 e5 mov %esp,%ebp 10b747: 56 push %esi 10b748: 53 push %ebx 10b749: 83 ec 10 sub $0x10,%esp 10b74c: 8b 5d 0c mov 0xc(%ebp),%ebx 10b74f: 8b 75 10 mov 0x10(%ebp),%esi register Thread_Control *the_thread; Objects_Locations location; if ( new_priority != RTEMS_CURRENT_PRIORITY && 10b752: 85 db test %ebx,%ebx 10b754: 74 0b je 10b761 bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ); 10b756: 0f b6 05 14 d1 11 00 movzbl 0x11d114,%eax 10b75d: 39 c3 cmp %eax,%ebx 10b75f: 77 5f ja 10b7c0 !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10b761: 85 f6 test %esi,%esi 10b763: 74 67 je 10b7cc <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10b765: 83 ec 08 sub $0x8,%esp 10b768: 8d 45 f4 lea -0xc(%ebp),%eax 10b76b: 50 push %eax 10b76c: ff 75 08 pushl 0x8(%ebp) 10b76f: e8 60 1c 00 00 call 10d3d4 <_Thread_Get> 10b774: 89 c2 mov %eax,%edx switch ( location ) { 10b776: 83 c4 10 add $0x10,%esp 10b779: 8b 45 f4 mov -0xc(%ebp),%eax 10b77c: 85 c0 test %eax,%eax 10b77e: 74 0c je 10b78c 10b780: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b785: 8d 65 f8 lea -0x8(%ebp),%esp 10b788: 5b pop %ebx 10b789: 5e pop %esi 10b78a: c9 leave 10b78b: c3 ret 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; 10b78c: 8b 42 14 mov 0x14(%edx),%eax 10b78f: 89 06 mov %eax,(%esi) if ( new_priority != RTEMS_CURRENT_PRIORITY ) { 10b791: 85 db test %ebx,%ebx 10b793: 74 1c je 10b7b1 the_thread->real_priority = new_priority; 10b795: 89 5a 18 mov %ebx,0x18(%edx) if ( the_thread->resource_count == 0 || 10b798: 8b 4a 1c mov 0x1c(%edx),%ecx 10b79b: 85 c9 test %ecx,%ecx 10b79d: 74 05 je 10b7a4 10b79f: 3b 5a 14 cmp 0x14(%edx),%ebx 10b7a2: 73 0d jae 10b7b1 <== ALWAYS TAKEN the_thread->current_priority > new_priority ) _Thread_Change_priority( the_thread, new_priority, FALSE ); 10b7a4: 50 push %eax 10b7a5: 6a 00 push $0x0 10b7a7: 53 push %ebx 10b7a8: 52 push %edx 10b7a9: e8 26 17 00 00 call 10ced4 <_Thread_Change_priority> 10b7ae: 83 c4 10 add $0x10,%esp } _Thread_Enable_dispatch(); 10b7b1: e8 fa 1b 00 00 call 10d3b0 <_Thread_Enable_dispatch> 10b7b6: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b7b8: 8d 65 f8 lea -0x8(%ebp),%esp 10b7bb: 5b pop %ebx 10b7bc: 5e pop %esi 10b7bd: c9 leave 10b7be: c3 ret 10b7bf: 90 nop 10b7c0: b8 13 00 00 00 mov $0x13,%eax 10b7c5: 8d 65 f8 lea -0x8(%ebp),%esp 10b7c8: 5b pop %ebx 10b7c9: 5e pop %esi 10b7ca: c9 leave 10b7cb: c3 ret if ( new_priority != RTEMS_CURRENT_PRIORITY && !_RTEMS_tasks_Priority_is_valid( new_priority ) ) return RTEMS_INVALID_PRIORITY; if ( !old_priority ) 10b7cc: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10b7d1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10b7d4: 5b pop %ebx <== NOT EXECUTED 10b7d5: 5e pop %esi <== NOT EXECUTED 10b7d6: c9 leave <== NOT EXECUTED 10b7d7: c3 ret <== NOT EXECUTED =============================================================================== 0010a828 : rtems_status_code rtems_task_start( rtems_id id, rtems_task_entry entry_point, rtems_task_argument argument ) { 10a828: 55 push %ebp 10a829: 89 e5 mov %esp,%ebp 10a82b: 53 push %ebx 10a82c: 83 ec 14 sub $0x14,%esp 10a82f: 8b 5d 0c mov 0xc(%ebp),%ebx register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 10a832: 85 db test %ebx,%ebx 10a834: 74 5a je 10a890 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get( id, &location ); 10a836: 83 ec 08 sub $0x8,%esp 10a839: 8d 45 f8 lea -0x8(%ebp),%eax 10a83c: 50 push %eax 10a83d: ff 75 08 pushl 0x8(%ebp) 10a840: e8 cb 1a 00 00 call 10c310 <_Thread_Get> switch ( location ) { 10a845: 83 c4 10 add $0x10,%esp 10a848: 8b 55 f8 mov -0x8(%ebp),%edx 10a84b: 85 d2 test %edx,%edx 10a84d: 74 0d je 10a85c 10a84f: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a854: 8b 5d fc mov -0x4(%ebp),%ebx 10a857: c9 leave 10a858: c3 ret 10a859: 8d 76 00 lea 0x0(%esi),%esi the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( _Thread_Start( 10a85c: 83 ec 0c sub $0xc,%esp 10a85f: ff 75 10 pushl 0x10(%ebp) 10a862: 6a 00 push $0x0 10a864: 53 push %ebx 10a865: 6a 00 push $0x0 10a867: 50 push %eax 10a868: e8 7b 25 00 00 call 10cde8 <_Thread_Start> 10a86d: 83 c4 20 add $0x20,%esp 10a870: 84 c0 test %al,%al 10a872: 75 10 jne 10a884 the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10a874: e8 73 1a 00 00 call 10c2ec <_Thread_Enable_dispatch> 10a879: b8 0e 00 00 00 mov $0xe,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a87e: 8b 5d fc mov -0x4(%ebp),%ebx 10a881: c9 leave 10a882: c3 ret 10a883: 90 nop switch ( location ) { case OBJECTS_LOCAL: if ( _Thread_Start( the_thread, THREAD_START_NUMERIC, entry_point, NULL, argument ) ) { _Thread_Enable_dispatch(); 10a884: e8 63 1a 00 00 call 10c2ec <_Thread_Enable_dispatch> 10a889: 31 c0 xor %eax,%eax 10a88b: eb c7 jmp 10a854 10a88d: 8d 76 00 lea 0x0(%esi),%esi ) { register Thread_Control *the_thread; Objects_Locations location; if ( entry_point == NULL ) 10a890: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10a895: 8b 5d fc mov -0x4(%ebp),%ebx 10a898: c9 leave 10a899: c3 ret =============================================================================== 0010ba38 : */ rtems_status_code rtems_task_suspend( Objects_Id id ) { 10ba38: 55 push %ebp 10ba39: 89 e5 mov %esp,%ebp 10ba3b: 83 ec 20 sub $0x20,%esp register Thread_Control *the_thread; Objects_Locations location; the_thread = _Thread_Get( id, &location ); 10ba3e: 8d 45 fc lea -0x4(%ebp),%eax 10ba41: 50 push %eax 10ba42: ff 75 08 pushl 0x8(%ebp) 10ba45: e8 be 1d 00 00 call 10d808 <_Thread_Get> switch ( location ) { 10ba4a: 83 c4 10 add $0x10,%esp 10ba4d: 8b 55 fc mov -0x4(%ebp),%edx 10ba50: 85 d2 test %edx,%edx 10ba52: 74 08 je 10ba5c 10ba54: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ba59: c9 leave 10ba5a: c3 ret 10ba5b: 90 nop the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { 10ba5c: f6 40 10 02 testb $0x2,0x10(%eax) 10ba60: 74 0e je 10ba70 _Thread_Suspend( the_thread ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } _Thread_Enable_dispatch(); 10ba62: e8 51 1d 00 00 call 10d7b8 <_Thread_Enable_dispatch> 10ba67: b8 0f 00 00 00 mov $0xf,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ba6c: c9 leave 10ba6d: c3 ret 10ba6e: 66 90 xchg %ax,%ax the_thread = _Thread_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_States_Is_suspended( the_thread->current_state ) ) { _Thread_Suspend( the_thread ); 10ba70: 83 ec 0c sub $0xc,%esp 10ba73: 50 push %eax 10ba74: e8 77 29 00 00 call 10e3f0 <_Thread_Suspend> _Thread_Enable_dispatch(); 10ba79: e8 3a 1d 00 00 call 10d7b8 <_Thread_Enable_dispatch> 10ba7e: 31 c0 xor %eax,%eax 10ba80: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10ba83: c9 leave 10ba84: c3 ret =============================================================================== 0010bce8 : rtems_status_code rtems_task_variable_add( rtems_id tid, void **ptr, void (*dtor)(void *) ) { 10bce8: 55 push %ebp 10bce9: 89 e5 mov %esp,%ebp 10bceb: 56 push %esi 10bcec: 53 push %ebx 10bced: 83 ec 10 sub $0x10,%esp 10bcf0: 8b 5d 0c mov 0xc(%ebp),%ebx Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 10bcf3: 85 db test %ebx,%ebx 10bcf5: 0f 84 a1 00 00 00 je 10bd9c <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 10bcfb: 83 ec 08 sub $0x8,%esp 10bcfe: 8d 45 f4 lea -0xc(%ebp),%eax 10bd01: 50 push %eax 10bd02: ff 75 08 pushl 0x8(%ebp) 10bd05: e8 9e 1c 00 00 call 10d9a8 <_Thread_Get> 10bd0a: 89 c6 mov %eax,%esi switch (location) { 10bd0c: 83 c4 10 add $0x10,%esp 10bd0f: 8b 45 f4 mov -0xc(%ebp),%eax 10bd12: 85 c0 test %eax,%eax 10bd14: 75 2e jne 10bd44 <== NEVER TAKEN case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; 10bd16: 8b 86 04 01 00 00 mov 0x104(%esi),%eax while (tvp) { 10bd1c: 85 c0 test %eax,%eax 10bd1e: 75 0a jne 10bd2a 10bd20: eb 2e jmp 10bd50 10bd22: 66 90 xchg %ax,%ax if (tvp->ptr == ptr) { tvp->dtor = dtor; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 10bd24: 8b 00 mov (%eax),%eax case OBJECTS_LOCAL: /* * Figure out if the variable is already in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 10bd26: 85 c0 test %eax,%eax 10bd28: 74 26 je 10bd50 if (tvp->ptr == ptr) { 10bd2a: 39 58 04 cmp %ebx,0x4(%eax) 10bd2d: 75 f5 jne 10bd24 tvp->dtor = dtor; 10bd2f: 8b 55 10 mov 0x10(%ebp),%edx 10bd32: 89 50 10 mov %edx,0x10(%eax) _Thread_Enable_dispatch(); 10bd35: e8 4a 1c 00 00 call 10d984 <_Thread_Enable_dispatch> 10bd3a: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bd3c: 8d 65 f8 lea -0x8(%ebp),%esp 10bd3f: 5b pop %ebx 10bd40: 5e pop %esi 10bd41: c9 leave 10bd42: c3 ret 10bd43: 90 nop if ( !ptr ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 10bd44: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bd49: 8d 65 f8 lea -0x8(%ebp),%esp 10bd4c: 5b pop %ebx 10bd4d: 5e pop %esi 10bd4e: c9 leave 10bd4f: c3 ret } /* * Now allocate memory for this task variable. */ new = (rtems_task_variable_t *) 10bd50: 83 ec 0c sub $0xc,%esp 10bd53: 6a 14 push $0x14 10bd55: e8 3a 2e 00 00 call 10eb94 <_Workspace_Allocate> 10bd5a: 89 c2 mov %eax,%edx _Workspace_Allocate(sizeof(rtems_task_variable_t)); if (new == NULL) { 10bd5c: 83 c4 10 add $0x10,%esp 10bd5f: 85 c0 test %eax,%eax 10bd61: 74 2d je 10bd90 _Thread_Enable_dispatch(); return RTEMS_NO_MEMORY; } new->gval = *ptr; 10bd63: 8b 03 mov (%ebx),%eax 10bd65: 89 42 08 mov %eax,0x8(%edx) new->ptr = ptr; 10bd68: 89 5a 04 mov %ebx,0x4(%edx) new->dtor = dtor; 10bd6b: 8b 45 10 mov 0x10(%ebp),%eax 10bd6e: 89 42 10 mov %eax,0x10(%edx) new->next = (struct rtems_task_variable_tt *)the_thread->task_variables; 10bd71: 8b 86 04 01 00 00 mov 0x104(%esi),%eax 10bd77: 89 02 mov %eax,(%edx) the_thread->task_variables = new; 10bd79: 89 96 04 01 00 00 mov %edx,0x104(%esi) _Thread_Enable_dispatch(); 10bd7f: e8 00 1c 00 00 call 10d984 <_Thread_Enable_dispatch> 10bd84: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bd86: 8d 65 f8 lea -0x8(%ebp),%esp 10bd89: 5b pop %ebx 10bd8a: 5e pop %esi 10bd8b: c9 leave 10bd8c: c3 ret 10bd8d: 8d 76 00 lea 0x0(%esi),%esi * 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(); 10bd90: e8 ef 1b 00 00 call 10d984 <_Thread_Enable_dispatch> 10bd95: b8 1a 00 00 00 mov $0x1a,%eax 10bd9a: eb ad jmp 10bd49 { Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *new; if ( !ptr ) 10bd9c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bda1: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10bda4: 5b pop %ebx <== NOT EXECUTED 10bda5: 5e pop %esi <== NOT EXECUTED 10bda6: c9 leave <== NOT EXECUTED 10bda7: c3 ret <== NOT EXECUTED =============================================================================== 0010bda8 : rtems_status_code rtems_task_variable_delete( rtems_id tid, void **ptr ) { 10bda8: 55 push %ebp 10bda9: 89 e5 mov %esp,%ebp 10bdab: 56 push %esi 10bdac: 53 push %ebx 10bdad: 83 ec 10 sub $0x10,%esp 10bdb0: 8b 5d 0c mov 0xc(%ebp),%ebx Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp, *prev; if ( !ptr ) 10bdb3: 85 db test %ebx,%ebx 10bdb5: 74 3f je 10bdf6 return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); 10bdb7: 83 ec 08 sub $0x8,%esp 10bdba: 8d 45 f4 lea -0xc(%ebp),%eax 10bdbd: 50 push %eax 10bdbe: ff 75 08 pushl 0x8(%ebp) 10bdc1: e8 e2 1b 00 00 call 10d9a8 <_Thread_Get> 10bdc6: 89 c6 mov %eax,%esi switch (location) { 10bdc8: 83 c4 10 add $0x10,%esp 10bdcb: 8b 45 f4 mov -0xc(%ebp),%eax 10bdce: 85 c0 test %eax,%eax 10bdd0: 75 32 jne 10be04 <== NEVER TAKEN case OBJECTS_LOCAL: tvp = the_thread->task_variables; 10bdd2: 8b 96 04 01 00 00 mov 0x104(%esi),%edx while (tvp) { 10bdd8: 85 d2 test %edx,%edx 10bdda: 74 15 je 10bdf1 if (tvp->ptr == ptr) { 10bddc: 39 5a 04 cmp %ebx,0x4(%edx) 10bddf: 75 08 jne 10bde9 10bde1: eb 4c jmp 10be2f 10bde3: 90 nop 10bde4: 39 5a 04 cmp %ebx,0x4(%edx) 10bde7: 74 27 je 10be10 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; 10bde9: 89 d1 mov %edx,%ecx } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; 10bdeb: 8b 12 mov (%edx),%edx the_thread = _Thread_Get (tid, &location); switch (location) { case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { 10bded: 85 d2 test %edx,%edx 10bdef: 75 f3 jne 10bde4 <== ALWAYS TAKEN return RTEMS_SUCCESSFUL; } prev = tvp; tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 10bdf1: e8 8e 1b 00 00 call 10d984 <_Thread_Enable_dispatch> 10bdf6: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bdfb: 8d 65 f8 lea -0x8(%ebp),%esp 10bdfe: 5b pop %ebx 10bdff: 5e pop %esi 10be00: c9 leave 10be01: c3 ret 10be02: 66 90 xchg %ax,%ax return RTEMS_INVALID_ADDRESS; prev = NULL; the_thread = _Thread_Get (tid, &location); switch (location) { 10be04: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be09: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10be0c: 5b pop %ebx <== NOT EXECUTED 10be0d: 5e pop %esi <== NOT EXECUTED 10be0e: c9 leave <== NOT EXECUTED 10be0f: c3 ret <== NOT EXECUTED case OBJECTS_LOCAL: tvp = the_thread->task_variables; while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; 10be10: 8b 02 mov (%edx),%eax 10be12: 89 01 mov %eax,(%ecx) else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; _RTEMS_Tasks_Invoke_task_variable_dtor( the_thread, tvp ); 10be14: 83 ec 08 sub $0x8,%esp 10be17: 52 push %edx 10be18: 56 push %esi 10be19: e8 a6 00 00 00 call 10bec4 <_RTEMS_Tasks_Invoke_task_variable_dtor> _Thread_Enable_dispatch(); 10be1e: e8 61 1b 00 00 call 10d984 <_Thread_Enable_dispatch> 10be23: 31 c0 xor %eax,%eax 10be25: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be28: 8d 65 f8 lea -0x8(%ebp),%esp 10be2b: 5b pop %ebx 10be2c: 5e pop %esi 10be2d: c9 leave 10be2e: c3 ret while (tvp) { if (tvp->ptr == ptr) { if (prev) prev->next = tvp->next; else the_thread->task_variables = (rtems_task_variable_t *)tvp->next; 10be2f: 8b 02 mov (%edx),%eax 10be31: 89 86 04 01 00 00 mov %eax,0x104(%esi) 10be37: eb db jmp 10be14 =============================================================================== 0010be3c : rtems_status_code rtems_task_variable_get( rtems_id tid, void **ptr, void **result ) { 10be3c: 55 push %ebp 10be3d: 89 e5 mov %esp,%ebp 10be3f: 56 push %esi 10be40: 53 push %ebx 10be41: 83 ec 10 sub $0x10,%esp 10be44: 8b 5d 0c mov 0xc(%ebp),%ebx 10be47: 8b 75 10 mov 0x10(%ebp),%esi Thread_Control *the_thread; Objects_Locations location; rtems_task_variable_t *tvp; if ( !ptr ) 10be4a: 85 db test %ebx,%ebx 10be4c: 74 56 je 10bea4 return RTEMS_INVALID_ADDRESS; if ( !result ) 10be4e: 85 f6 test %esi,%esi 10be50: 74 52 je 10bea4 return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); 10be52: 83 ec 08 sub $0x8,%esp 10be55: 8d 45 f4 lea -0xc(%ebp),%eax 10be58: 50 push %eax 10be59: ff 75 08 pushl 0x8(%ebp) 10be5c: e8 47 1b 00 00 call 10d9a8 <_Thread_Get> switch (location) { 10be61: 83 c4 10 add $0x10,%esp 10be64: 8b 55 f4 mov -0xc(%ebp),%edx 10be67: 85 d2 test %edx,%edx 10be69: 75 2d jne 10be98 <== NEVER TAKEN case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; 10be6b: 8b 80 04 01 00 00 mov 0x104(%eax),%eax while (tvp) { 10be71: 85 c0 test %eax,%eax 10be73: 75 09 jne 10be7e 10be75: eb 39 jmp 10beb0 10be77: 90 nop */ *result = tvp->tval; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; 10be78: 8b 00 mov (%eax),%eax case OBJECTS_LOCAL: /* * Figure out if the variable is in this task's list. */ tvp = the_thread->task_variables; while (tvp) { 10be7a: 85 c0 test %eax,%eax 10be7c: 74 32 je 10beb0 <== NEVER TAKEN if (tvp->ptr == ptr) { 10be7e: 39 58 04 cmp %ebx,0x4(%eax) 10be81: 75 f5 jne 10be78 /* * Should this return the current (i.e not the * saved) value if `tid' is the current task? */ *result = tvp->tval; 10be83: 8b 40 0c mov 0xc(%eax),%eax 10be86: 89 06 mov %eax,(%esi) _Thread_Enable_dispatch(); 10be88: e8 f7 1a 00 00 call 10d984 <_Thread_Enable_dispatch> 10be8d: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be8f: 8d 65 f8 lea -0x8(%ebp),%esp 10be92: 5b pop %ebx 10be93: 5e pop %esi 10be94: c9 leave 10be95: c3 ret 10be96: 66 90 xchg %ax,%ax if ( !result ) return RTEMS_INVALID_ADDRESS; the_thread = _Thread_Get (tid, &location); switch (location) { 10be98: b8 04 00 00 00 mov $0x4,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10be9d: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 10bea0: 5b pop %ebx <== NOT EXECUTED 10bea1: 5e pop %esi <== NOT EXECUTED 10bea2: c9 leave <== NOT EXECUTED 10bea3: c3 ret <== NOT EXECUTED return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); return RTEMS_INVALID_ADDRESS; 10bea4: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10bea9: 8d 65 f8 lea -0x8(%ebp),%esp 10beac: 5b pop %ebx 10bead: 5e pop %esi 10beae: c9 leave 10beaf: c3 ret _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } tvp = (rtems_task_variable_t *)tvp->next; } _Thread_Enable_dispatch(); 10beb0: e8 cf 1a 00 00 call 10d984 <_Thread_Enable_dispatch> 10beb5: b8 09 00 00 00 mov $0x9,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 10beba: 8d 65 f8 lea -0x8(%ebp),%esp 10bebd: 5b pop %ebx 10bebe: 5e pop %esi 10bebf: c9 leave 10bec0: c3 ret =============================================================================== 0010b524 : */ rtems_status_code rtems_task_wake_when( rtems_time_of_day *time_buffer ) { 10b524: 55 push %ebp 10b525: 89 e5 mov %esp,%ebp 10b527: 53 push %ebx 10b528: 83 ec 04 sub $0x4,%esp 10b52b: 8b 5d 08 mov 0x8(%ebp),%ebx Watchdog_Interval seconds; if ( !_TOD_Is_set ) 10b52e: 80 3d cc 16 12 00 00 cmpb $0x0,0x1216cc 10b535: 0f 84 a1 00 00 00 je 10b5dc return RTEMS_NOT_DEFINED; if ( !time_buffer ) 10b53b: 85 db test %ebx,%ebx 10b53d: 0f 84 a5 00 00 00 je 10b5e8 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; time_buffer->ticks = 0; 10b543: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) if ( !_TOD_Validate( time_buffer ) ) 10b54a: 83 ec 0c sub $0xc,%esp 10b54d: 53 push %ebx 10b54e: e8 c1 f3 ff ff call 10a914 <_TOD_Validate> 10b553: 83 c4 10 add $0x10,%esp 10b556: 84 c0 test %al,%al 10b558: 75 0a jne 10b564 _Watchdog_Insert_seconds( &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 10b55a: b8 14 00 00 00 mov $0x14,%eax } 10b55f: 8b 5d fc mov -0x4(%ebp),%ebx 10b562: c9 leave 10b563: c3 ret time_buffer->ticks = 0; if ( !_TOD_Validate( time_buffer ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( time_buffer ); 10b564: 83 ec 0c sub $0xc,%esp 10b567: 53 push %ebx 10b568: e8 17 f3 ff ff call 10a884 <_TOD_To_seconds> 10b56d: 89 c3 mov %eax,%ebx if ( seconds <= _TOD_Seconds_since_epoch ) 10b56f: 83 c4 10 add $0x10,%esp 10b572: 3b 05 4c 17 12 00 cmp 0x12174c,%eax 10b578: 76 e0 jbe 10b55a /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 10b57a: a1 b8 16 12 00 mov 0x1216b8,%eax 10b57f: 40 inc %eax 10b580: a3 b8 16 12 00 mov %eax,0x1216b8 return RTEMS_INVALID_CLOCK; _Thread_Disable_dispatch(); _Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_TIME ); 10b585: 83 ec 08 sub $0x8,%esp 10b588: 6a 10 push $0x10 10b58a: ff 35 7c 17 12 00 pushl 0x12177c 10b590: e8 7f 23 00 00 call 10d914 <_Thread_Set_state> _Watchdog_Initialize( 10b595: a1 7c 17 12 00 mov 0x12177c,%eax 10b59a: 8b 50 08 mov 0x8(%eax),%edx * 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. * 10b59d: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) * @param[in] the_heap is the heap to operate upon 10b5a4: c7 40 64 c8 ce 10 00 movl $0x10cec8,0x64(%eax) * @param[in] starting_address is the starting address of the memory for 10b5ab: 89 50 68 mov %edx,0x68(%eax) * the heap 10b5ae: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax) * @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, 10b5b5: 2b 1d 4c 17 12 00 sub 0x12174c,%ebx 10b5bb: 89 58 54 mov %ebx,0x54(%eax) size_t size ); 10b5be: 5a pop %edx 10b5bf: 59 pop %ecx 10b5c0: 83 c0 48 add $0x48,%eax 10b5c3: 50 push %eax 10b5c4: 68 90 17 12 00 push $0x121790 10b5c9: e8 1e 2a 00 00 call 10dfec <_Watchdog_Insert> ); _Watchdog_Insert_seconds( &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); 10b5ce: e8 8d 1a 00 00 call 10d060 <_Thread_Enable_dispatch> 10b5d3: 31 c0 xor %eax,%eax 10b5d5: 83 c4 10 add $0x10,%esp 10b5d8: eb 85 jmp 10b55f 10b5da: 66 90 xchg %ax,%ax rtems_time_of_day *time_buffer ) { Watchdog_Interval seconds; if ( !_TOD_Is_set ) 10b5dc: b8 0b 00 00 00 mov $0xb,%eax &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b5e1: 8b 5d fc mov -0x4(%ebp),%ebx 10b5e4: c9 leave 10b5e5: c3 ret 10b5e6: 66 90 xchg %ax,%ax Watchdog_Interval seconds; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !time_buffer ) 10b5e8: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED &_Thread_Executing->Timer, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 10b5ed: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 10b5f0: c9 leave <== NOT EXECUTED 10b5f1: c3 ret <== NOT EXECUTED =============================================================================== 00107fd8 : rtems_status_code rtems_termios_bufsize ( int cbufsize, int raw_input, int raw_output ) { 107fd8: 55 push %ebp <== NOT EXECUTED 107fd9: 89 e5 mov %esp,%ebp <== NOT EXECUTED rtems_termios_cbufsize = cbufsize; 107fdb: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 107fde: a3 84 c4 11 00 mov %eax,0x11c484 <== NOT EXECUTED rtems_termios_raw_input_size = raw_input; 107fe3: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 107fe6: a3 88 c4 11 00 mov %eax,0x11c488 <== NOT EXECUTED rtems_termios_raw_output_size = raw_output; 107feb: 8b 45 10 mov 0x10(%ebp),%eax <== NOT EXECUTED 107fee: a3 8c c4 11 00 mov %eax,0x11c48c <== NOT EXECUTED return RTEMS_SUCCESSFUL; } 107ff3: 31 c0 xor %eax,%eax <== NOT EXECUTED 107ff5: c9 leave <== NOT EXECUTED 107ff6: c3 ret <== NOT EXECUTED =============================================================================== 00109418 : } } rtems_status_code rtems_termios_close (void *arg) { 109418: 55 push %ebp 109419: 89 e5 mov %esp,%ebp 10941b: 56 push %esi 10941c: 53 push %ebx 10941d: 8b 75 08 mov 0x8(%ebp),%esi rtems_libio_open_close_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 109420: 8b 06 mov (%esi),%eax 109422: 8b 58 28 mov 0x28(%eax),%ebx rtems_status_code sc; sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 109425: 51 push %ecx 109426: 6a 00 push $0x0 109428: 6a 00 push $0x0 10942a: ff 35 8c e5 11 00 pushl 0x11e58c 109430: e8 bb 0f 00 00 call 10a3f0 if (sc != RTEMS_SUCCESSFUL) 109435: 83 c4 10 add $0x10,%esp 109438: 85 c0 test %eax,%eax 10943a: 0f 85 2c 01 00 00 jne 10956c <== NEVER TAKEN rtems_fatal_error_occurred (sc); if (--tty->refcount == 0) { 109440: 8b 43 08 mov 0x8(%ebx),%eax 109443: 48 dec %eax 109444: 89 43 08 mov %eax,0x8(%ebx) 109447: 85 c0 test %eax,%eax 109449: 0f 85 bf 00 00 00 jne 10950e if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 10944f: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax 109455: c1 e0 05 shl $0x5,%eax 109458: 8b 80 c4 e2 11 00 mov 0x11e2c4(%eax),%eax 10945e: 85 c0 test %eax,%eax 109460: 0f 84 12 01 00 00 je 109578 <== ALWAYS TAKEN /* * call discipline-specific close */ sc = rtems_termios_linesw[tty->t_line].l_close(tty); 109466: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109469: 53 push %ebx <== NOT EXECUTED 10946a: ff d0 call *%eax <== NOT EXECUTED 10946c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED * default: just flush output buffer */ drainOutput (tty); } if (tty->device.outputUsesInterrupts 10946f: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 109476: 0f 84 bc 00 00 00 je 109538 <== NEVER TAKEN tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } if (tty->device.lastClose) 10947c: 8b 83 9c 00 00 00 mov 0x9c(%ebx),%eax 109482: 85 c0 test %eax,%eax 109484: 74 0d je 109493 <== NEVER TAKEN (*tty->device.lastClose)(tty->major, tty->minor, arg); 109486: 52 push %edx 109487: 56 push %esi 109488: ff 73 10 pushl 0x10(%ebx) 10948b: ff 73 0c pushl 0xc(%ebx) 10948e: ff d0 call *%eax 109490: 83 c4 10 add $0x10,%esp if (tty->forw == NULL) { 109493: 8b 13 mov (%ebx),%edx 109495: 85 d2 test %edx,%edx 109497: 0f 84 e7 00 00 00 je 109584 <== ALWAYS TAKEN if ( rtems_termios_ttyTail != NULL ) { rtems_termios_ttyTail->forw = NULL; } } else { tty->forw->back = tty->back; 10949d: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 1094a0: 89 42 04 mov %eax,0x4(%edx) <== NOT EXECUTED } if (tty->back == NULL) { 1094a3: 8b 43 04 mov 0x4(%ebx),%eax <== NOT EXECUTED 1094a6: 85 c0 test %eax,%eax <== NOT EXECUTED 1094a8: 0f 84 f2 00 00 00 je 1095a0 <== NOT EXECUTED if ( rtems_termios_ttyHead != NULL ) { rtems_termios_ttyHead->back = NULL; } } else { tty->back->forw = tty->forw; 1094ae: 89 10 mov %edx,(%eax) <== NOT EXECUTED } rtems_semaphore_delete (tty->isem); 1094b0: 83 ec 0c sub $0xc,%esp 1094b3: ff 73 14 pushl 0x14(%ebx) 1094b6: e8 91 0e 00 00 call 10a34c rtems_semaphore_delete (tty->osem); 1094bb: 58 pop %eax 1094bc: ff 73 18 pushl 0x18(%ebx) 1094bf: e8 88 0e 00 00 call 10a34c rtems_semaphore_delete (tty->rawOutBuf.Semaphore); 1094c4: 58 pop %eax 1094c5: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 1094cb: e8 7c 0e 00 00 call 10a34c if ((tty->device.pollRead == NULL) || 1094d0: 83 c4 10 add $0x10,%esp 1094d3: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax 1094d9: 85 c0 test %eax,%eax 1094db: 74 4b je 109528 <== ALWAYS TAKEN 1094dd: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) <== NOT EXECUTED 1094e4: 74 42 je 109528 <== NOT EXECUTED (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore); free (tty->rawInBuf.theBuf); 1094e6: 83 ec 0c sub $0xc,%esp 1094e9: ff 73 58 pushl 0x58(%ebx) 1094ec: e8 cf db ff ff call 1070c0 free (tty->rawOutBuf.theBuf); 1094f1: 58 pop %eax 1094f2: ff 73 7c pushl 0x7c(%ebx) 1094f5: e8 c6 db ff ff call 1070c0 free (tty->cbuf); 1094fa: 5e pop %esi 1094fb: ff 73 1c pushl 0x1c(%ebx) 1094fe: e8 bd db ff ff call 1070c0 free (tty); 109503: 89 1c 24 mov %ebx,(%esp) 109506: e8 b5 db ff ff call 1070c0 10950b: 83 c4 10 add $0x10,%esp } rtems_semaphore_release (rtems_termios_ttyMutex); 10950e: 83 ec 0c sub $0xc,%esp 109511: ff 35 8c e5 11 00 pushl 0x11e58c 109517: e8 cc 0f 00 00 call 10a4e8 return RTEMS_SUCCESSFUL; } 10951c: 31 c0 xor %eax,%eax 10951e: 8d 65 f8 lea -0x8(%ebp),%esp 109521: 5b pop %ebx 109522: 5e pop %esi 109523: c9 leave 109524: c3 ret 109525: 8d 76 00 lea 0x0(%esi),%esi 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); 109528: 83 ec 0c sub $0xc,%esp 10952b: ff 73 68 pushl 0x68(%ebx) 10952e: e8 19 0e 00 00 call 10a34c 109533: 83 c4 10 add $0x10,%esp 109536: eb ae jmp 1094e6 if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { /* * send "terminate" to I/O tasks */ sc = rtems_event_send( 109538: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10953b: 6a 01 push $0x1 <== NOT EXECUTED 10953d: ff b3 c4 00 00 00 pushl 0xc4(%ebx) <== NOT EXECUTED 109543: e8 84 09 00 00 call 109ecc <== NOT EXECUTED tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) 109548: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10954b: 85 c0 test %eax,%eax <== NOT EXECUTED 10954d: 75 1d jne 10956c <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_event_send( 10954f: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109552: 6a 01 push $0x1 <== NOT EXECUTED 109554: ff b3 c8 00 00 00 pushl 0xc8(%ebx) <== NOT EXECUTED 10955a: e8 6d 09 00 00 call 109ecc <== NOT EXECUTED tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT); if (sc != RTEMS_SUCCESSFUL) 10955f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109562: 85 c0 test %eax,%eax <== NOT EXECUTED 109564: 0f 84 12 ff ff ff je 10947c <== NOT EXECUTED 10956a: 66 90 xchg %ax,%ax <== NOT EXECUTED rtems_fatal_error_occurred (sc); 10956c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10956f: 50 push %eax <== NOT EXECUTED 109570: e8 0f 15 00 00 call 10aa84 <== NOT EXECUTED 109575: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } else { /* * default: just flush output buffer */ drainOutput (tty); 109578: 89 d8 mov %ebx,%eax 10957a: e8 d5 f6 ff ff call 108c54 10957f: e9 eb fe ff ff jmp 10946f 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; 109584: 8b 43 04 mov 0x4(%ebx),%eax 109587: a3 90 e5 11 00 mov %eax,0x11e590 if ( rtems_termios_ttyTail != NULL ) { 10958c: 85 c0 test %eax,%eax 10958e: 74 2c je 1095bc <== ALWAYS TAKEN rtems_termios_ttyTail->forw = NULL; 109590: c7 00 00 00 00 00 movl $0x0,(%eax) <== NOT EXECUTED 109596: 8b 13 mov (%ebx),%edx <== NOT EXECUTED 109598: e9 06 ff ff ff jmp 1094a3 <== NOT EXECUTED 10959d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED } else { tty->forw->back = tty->back; } if (tty->back == NULL) { rtems_termios_ttyHead = tty->forw; 1095a0: 89 15 94 e5 11 00 mov %edx,0x11e594 <== NOT EXECUTED if ( rtems_termios_ttyHead != NULL ) { 1095a6: 85 d2 test %edx,%edx <== NOT EXECUTED 1095a8: 0f 84 02 ff ff ff je 1094b0 <== NOT EXECUTED rtems_termios_ttyHead->back = NULL; 1095ae: c7 42 04 00 00 00 00 movl $0x0,0x4(%edx) <== NOT EXECUTED 1095b5: e9 f6 fe ff ff jmp 1094b0 <== NOT EXECUTED 1095ba: 66 90 xchg %ax,%ax <== NOT EXECUTED } else { tty->forw->back = tty->back; } if (tty->back == NULL) { rtems_termios_ttyHead = tty->forw; 1095bc: c7 05 94 e5 11 00 00 movl $0x0,0x11e594 1095c3: 00 00 00 1095c6: e9 e5 fe ff ff jmp 1094b0 =============================================================================== 00108238 : * for each transmitted character. * It returns number of characters left to transmit */ int rtems_termios_dequeue_characters (void *ttyp, int len) { 108238: 55 push %ebp 108239: 89 e5 mov %esp,%ebp 10823b: 83 ec 08 sub $0x8,%esp 10823e: 8b 55 08 mov 0x8(%ebp),%edx rtems_status_code sc; /* * sum up character count already sent */ tty->t_dqlen += len; 108241: 8b 45 0c mov 0xc(%ebp),%eax 108244: 01 82 90 00 00 00 add %eax,0x90(%edx) if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 10824a: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx) 108251: 74 2d je 108280 <== NEVER TAKEN 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 ) { 108253: 83 ba cc 00 00 00 05 cmpl $0x5,0xcc(%edx) 10825a: 75 18 jne 108274 <== ALWAYS TAKEN /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 10825c: a1 74 e3 11 00 mov 0x11e374,%eax <== NOT EXECUTED 108261: 85 c0 test %eax,%eax <== NOT EXECUTED 108263: 74 09 je 10826e <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_start(tty); 108265: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108268: 52 push %edx <== NOT EXECUTED 108269: ff d0 call *%eax <== NOT EXECUTED 10826b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return 0; /* nothing to output in IRQ... */ } else { return rtems_termios_refill_transmitter(tty); } } 10826e: 31 c0 xor %eax,%eax <== NOT EXECUTED 108270: c9 leave <== NOT EXECUTED 108271: c3 ret <== NOT EXECUTED 108272: 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); 108274: 89 55 08 mov %edx,0x8(%ebp) } } 108277: c9 leave rtems_termios_linesw[tty->t_line].l_start(tty); } return 0; /* nothing to output in IRQ... */ } else { return rtems_termios_refill_transmitter(tty); 108278: e9 97 fd ff ff jmp 108014 10827d: 8d 76 00 lea 0x0(%esi),%esi if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { /* * send wake up to transmitter task */ sc = rtems_event_send(tty->txTaskId, 108280: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 108283: 6a 02 push $0x2 <== NOT EXECUTED 108285: ff b2 c8 00 00 00 pushl 0xc8(%edx) <== NOT EXECUTED 10828b: e8 3c 1c 00 00 call 109ecc <== NOT EXECUTED TERMIOS_TX_START_EVENT); if (sc != RTEMS_SUCCESSFUL) 108290: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108293: 85 c0 test %eax,%eax <== NOT EXECUTED 108295: 74 d7 je 10826e <== NOT EXECUTED rtems_fatal_error_occurred (sc); 108297: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10829a: 50 push %eax <== NOT EXECUTED 10829b: e8 e4 27 00 00 call 10aa84 <== NOT EXECUTED =============================================================================== 001082a0 : * 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) { 1082a0: 55 push %ebp <== NOT EXECUTED 1082a1: 89 e5 mov %esp,%ebp <== NOT EXECUTED 1082a3: 57 push %edi <== NOT EXECUTED 1082a4: 56 push %esi <== NOT EXECUTED 1082a5: 53 push %ebx <== NOT EXECUTED 1082a6: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 1082a9: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED 1082ac: 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) { 1082af: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED 1082b5: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 1082b8: 8b 90 d0 e2 11 00 mov 0x11e2d0(%eax),%edx <== NOT EXECUTED 1082be: 85 d2 test %edx,%edx <== NOT EXECUTED 1082c0: 0f 84 86 00 00 00 je 10834c <== NOT EXECUTED while (len--) { 1082c6: 85 ff test %edi,%edi <== NOT EXECUTED 1082c8: 74 2b je 1082f5 <== NOT EXECUTED 1082ca: 31 db xor %ebx,%ebx <== NOT EXECUTED 1082cc: eb 11 jmp 1082df <== NOT EXECUTED 1082ce: 66 90 xchg %ax,%ax <== NOT EXECUTED 1082d0: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED 1082d6: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 1082d9: 8b 90 d0 e2 11 00 mov 0x11e2d0(%eax),%edx <== NOT EXECUTED c = *buf++; rtems_termios_linesw[tty->t_line].l_rint(c,tty); 1082df: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1082e2: 56 push %esi <== NOT EXECUTED 1082e3: 8b 4d 0c mov 0xc(%ebp),%ecx <== NOT EXECUTED 1082e6: 0f be 04 19 movsbl (%ecx,%ebx,1),%eax <== NOT EXECUTED 1082ea: 50 push %eax <== NOT EXECUTED 1082eb: ff d2 call *%edx <== NOT EXECUTED 1082ed: 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--) { 1082ee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1082f1: 39 fb cmp %edi,%ebx <== NOT EXECUTED 1082f3: 75 db jne 1082d0 <== NOT EXECUTED } /* * check to see if rcv wakeup callback was set */ if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) { 1082f5: 8b 9e e4 00 00 00 mov 0xe4(%esi),%ebx <== NOT EXECUTED 1082fb: 85 db test %ebx,%ebx <== NOT EXECUTED 1082fd: 75 39 jne 108338 <== NOT EXECUTED 1082ff: 8b 96 dc 00 00 00 mov 0xdc(%esi),%edx <== NOT EXECUTED 108305: 85 d2 test %edx,%edx <== NOT EXECUTED 108307: 74 2f je 108338 <== NOT EXECUTED (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 108309: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10830c: ff b6 e0 00 00 00 pushl 0xe0(%esi) <== NOT EXECUTED 108312: 8d 46 30 lea 0x30(%esi),%eax <== NOT EXECUTED 108315: 50 push %eax <== NOT EXECUTED 108316: ff d2 call *%edx <== NOT EXECUTED tty->tty_rcvwakeup = 1; 108318: c7 86 e4 00 00 00 01 movl $0x1,0xe4(%esi) <== NOT EXECUTED 10831f: 00 00 00 108322: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) <== NOT EXECUTED 108329: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; } 10832c: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 10832f: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108332: 5b pop %ebx <== NOT EXECUTED 108333: 5e pop %esi <== NOT EXECUTED 108334: 5f pop %edi <== NOT EXECUTED 108335: c9 leave <== NOT EXECUTED 108336: c3 ret <== NOT EXECUTED 108337: 90 nop <== NOT EXECUTED } } } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; 108338: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) <== NOT EXECUTED } 10833f: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 108342: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108345: 5b pop %ebx <== NOT EXECUTED 108346: 5e pop %esi <== NOT EXECUTED 108347: 5f pop %edi <== NOT EXECUTED 108348: c9 leave <== NOT EXECUTED 108349: c3 ret <== NOT EXECUTED 10834a: 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, 10834c: 8d 46 4a lea 0x4a(%esi),%eax <== NOT EXECUTED 10834f: 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); 108352: 8d 56 30 lea 0x30(%esi),%edx <== NOT EXECUTED 108355: 89 55 f0 mov %edx,-0x10(%ebp) <== NOT EXECUTED 108358: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp) <== NOT EXECUTED 10835f: c6 45 ea 00 movb $0x0,-0x16(%ebp) <== NOT EXECUTED 108363: e9 c3 00 00 00 jmp 10842b <== NOT EXECUTED /* reenable interrupts */ rtems_interrupt_enable(level); } } else { newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size; 108368: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED 10836b: 8b 4e 64 mov 0x64(%esi),%ecx <== NOT EXECUTED 10836e: 40 inc %eax <== NOT EXECUTED 10836f: 31 d2 xor %edx,%edx <== NOT EXECUTED 108371: f7 f1 div %ecx <== NOT EXECUTED 108373: 89 d3 mov %edx,%ebx <== NOT EXECUTED /* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); 108375: 9c pushf <== NOT EXECUTED 108376: fa cli <== NOT EXECUTED 108377: 8f 45 ec popl -0x14(%ebp) <== NOT EXECUTED if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size) 10837a: 8b 4e 5c mov 0x5c(%esi),%ecx <== NOT EXECUTED 10837d: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED 108380: 8b 56 64 mov 0x64(%esi),%edx <== NOT EXECUTED 108383: 29 c8 sub %ecx,%eax <== NOT EXECUTED 108385: 01 d8 add %ebx,%eax <== NOT EXECUTED 108387: 89 d1 mov %edx,%ecx <== NOT EXECUTED 108389: 31 d2 xor %edx,%edx <== NOT EXECUTED 10838b: f7 f1 div %ecx <== NOT EXECUTED 10838d: 3b 96 c0 00 00 00 cmp 0xc0(%esi),%edx <== NOT EXECUTED 108393: 76 47 jbe 1083dc <== NOT EXECUTED 108395: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 10839b: a8 01 test $0x1,%al <== NOT EXECUTED 10839d: 75 3d jne 1083dc <== NOT EXECUTED % tty->rawInBuf.Size) > tty->highwater) && !(tty->flow_ctrl & FL_IREQXOF)) { /* incoming data stream should be stopped */ tty->flow_ctrl |= FL_IREQXOF; 10839f: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 1083a5: 83 c8 01 or $0x1,%eax <== NOT EXECUTED 1083a8: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF)) 1083ae: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 1083b4: 25 02 04 00 00 and $0x402,%eax <== NOT EXECUTED 1083b9: 3d 00 04 00 00 cmp $0x400,%eax <== NOT EXECUTED 1083be: 0f 84 5e 01 00 00 je 108522 <== NOT EXECUTED (*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) 1083c4: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 1083ca: 25 04 01 00 00 and $0x104,%eax <== NOT EXECUTED 1083cf: 3d 00 01 00 00 cmp $0x100,%eax <== NOT EXECUTED 1083d4: 0f 84 86 01 00 00 je 108560 <== NOT EXECUTED 1083da: 66 90 xchg %ax,%ax <== NOT EXECUTED tty->device.stopRemoteTx(tty->minor); } } } /* reenable interrupts */ rtems_interrupt_enable(level); 1083dc: ff 75 ec pushl -0x14(%ebp) <== NOT EXECUTED 1083df: 9d popf <== NOT EXECUTED if (newTail == tty->rawInBuf.Head) { 1083e0: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED 1083e3: 39 d8 cmp %ebx,%eax <== NOT EXECUTED 1083e5: 0f 84 91 00 00 00 je 10847c <== NOT EXECUTED dropped++; } else { tty->rawInBuf.theBuf[newTail] = c; 1083eb: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED 1083ee: 8a 55 eb mov -0x15(%ebp),%dl <== NOT EXECUTED 1083f1: 88 14 18 mov %dl,(%eax,%ebx,1) <== NOT EXECUTED tty->rawInBuf.Tail = newTail; 1083f4: 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 )) { 1083f7: 8b 9e e4 00 00 00 mov 0xe4(%esi),%ebx <== NOT EXECUTED 1083fd: 85 db test %ebx,%ebx <== NOT EXECUTED 1083ff: 75 27 jne 108428 <== NOT EXECUTED 108401: 8b 86 dc 00 00 00 mov 0xdc(%esi),%eax <== NOT EXECUTED 108407: 85 c0 test %eax,%eax <== NOT EXECUTED 108409: 74 1d je 108428 <== NOT EXECUTED (*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg); 10840b: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10840e: ff b6 e0 00 00 00 pushl 0xe0(%esi) <== NOT EXECUTED 108414: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 108417: ff d0 call *%eax <== NOT EXECUTED tty->tty_rcvwakeup = 1; 108419: c7 86 e4 00 00 00 01 movl $0x1,0xe4(%esi) <== NOT EXECUTED 108420: 00 00 00 108423: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108426: 66 90 xchg %ax,%ax <== NOT EXECUTED } return 0; } while (len--) { c = *buf++; 108428: ff 45 0c incl 0xc(%ebp) <== NOT EXECUTED tty->tty_rcvwakeup = 1; } return 0; } while (len--) { 10842b: 4f dec %edi <== NOT EXECUTED 10842c: 83 ff ff cmp $0xffffffff,%edi <== NOT EXECUTED 10842f: 0f 84 9f 00 00 00 je 1084d4 <== NOT EXECUTED c = *buf++; 108435: 8b 45 0c mov 0xc(%ebp),%eax <== NOT EXECUTED 108438: 8a 00 mov (%eax),%al <== NOT EXECUTED 10843a: 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) { 10843d: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108443: f6 c4 02 test $0x2,%ah <== NOT EXECUTED 108446: 74 14 je 10845c <== NOT EXECUTED /* if received char is V_STOP and V_START (both are equal value) */ if (c == tty->termios.c_cc[VSTOP]) { 108448: 0f be 55 eb movsbl -0x15(%ebp),%edx <== NOT EXECUTED 10844c: 0f b6 46 4a movzbl 0x4a(%esi),%eax <== NOT EXECUTED 108450: 39 c2 cmp %eax,%edx <== NOT EXECUTED 108452: 74 50 je 1084a4 <== NOT EXECUTED /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; } flow_rcv = true; } else if (c == tty->termios.c_cc[VSTART]) { 108454: 0f b6 46 49 movzbl 0x49(%esi),%eax <== NOT EXECUTED 108458: 39 c2 cmp %eax,%edx <== NOT EXECUTED 10845a: 74 64 je 1084c0 <== NOT EXECUTED /* restart output */ tty->flow_ctrl &= ~FL_ORCVXOF; flow_rcv = true; } } if (flow_rcv) { 10845c: 80 7d ea 00 cmpb $0x0,-0x16(%ebp) <== NOT EXECUTED 108460: 0f 84 02 ff ff ff je 108368 <== NOT EXECUTED /* restart output according to FL_ORCVXOF flag */ if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) { 108466: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 10846c: 83 e0 30 and $0x30,%eax <== NOT EXECUTED 10846f: 83 f8 20 cmp $0x20,%eax <== NOT EXECUTED 108472: 74 10 je 108484 <== 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); 108474: c6 45 ea 01 movb $0x1,-0x16(%ebp) <== NOT EXECUTED 108478: eb ae jmp 108428 <== NOT EXECUTED 10847a: 66 90 xchg %ax,%ax <== NOT EXECUTED } /* reenable interrupts */ rtems_interrupt_enable(level); if (newTail == tty->rawInBuf.Head) { dropped++; 10847c: ff 45 e4 incl -0x1c(%ebp) <== NOT EXECUTED 10847f: eb a7 jmp 108428 <== NOT EXECUTED 108481: 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); 108484: 9c pushf <== NOT EXECUTED 108485: fa cli <== NOT EXECUTED 108486: 5b pop %ebx <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 108487: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 10848d: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 108490: 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) { 108496: 8b 8e 94 00 00 00 mov 0x94(%esi),%ecx <== NOT EXECUTED 10849c: 85 c9 test %ecx,%ecx <== NOT EXECUTED 10849e: 75 53 jne 1084f3 <== 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); 1084a0: 53 push %ebx <== NOT EXECUTED 1084a1: 9d popf <== NOT EXECUTED 1084a2: eb d0 jmp 108474 <== 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]) { 1084a4: 0f b6 46 49 movzbl 0x49(%esi),%eax <== NOT EXECUTED 1084a8: 39 c2 cmp %eax,%edx <== NOT EXECUTED 1084aa: 74 62 je 10850e <== NOT EXECUTED tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF; } else { /* VSTOP received (other code than VSTART) */ /* stop output */ tty->flow_ctrl |= FL_ORCVXOF; 1084ac: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 1084b2: 83 c8 10 or $0x10,%eax <== NOT EXECUTED 1084b5: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED 1084bb: eb a9 jmp 108466 <== NOT EXECUTED 1084bd: 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; 1084c0: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 1084c6: 83 e0 ef and $0xffffffef,%eax <== NOT EXECUTED 1084c9: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED 1084cf: eb 95 jmp 108466 <== NOT EXECUTED 1084d1: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED tty->tty_rcvwakeup = 1; } } } } tty->rawInBufDropped += dropped; 1084d4: 8b 4d e4 mov -0x1c(%ebp),%ecx <== NOT EXECUTED 1084d7: 01 4e 78 add %ecx,0x78(%esi) <== NOT EXECUTED rtems_semaphore_release (tty->rawInBuf.Semaphore); 1084da: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1084dd: ff 76 68 pushl 0x68(%esi) <== NOT EXECUTED 1084e0: e8 03 20 00 00 call 10a4e8 <== NOT EXECUTED 1084e5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return dropped; } 1084e8: 8b 45 e4 mov -0x1c(%ebp),%eax <== NOT EXECUTED 1084eb: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1084ee: 5b pop %ebx <== NOT EXECUTED 1084ef: 5e pop %esi <== NOT EXECUTED 1084f0: 5f pop %edi <== NOT EXECUTED 1084f1: c9 leave <== NOT EXECUTED 1084f2: 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, 1084f3: 8b 86 84 00 00 00 mov 0x84(%esi),%eax <== NOT EXECUTED 1084f9: 52 push %edx <== NOT EXECUTED 1084fa: 6a 01 push $0x1 <== NOT EXECUTED 1084fc: 03 46 7c add 0x7c(%esi),%eax <== NOT EXECUTED 1084ff: 50 push %eax <== NOT EXECUTED 108500: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 108503: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED 108509: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10850c: eb 92 jmp 1084a0 <== 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; 10850e: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108514: 83 f0 10 xor $0x10,%eax <== NOT EXECUTED 108517: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED 10851d: e9 44 ff ff ff jmp 108466 <== 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) || 108522: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108528: a8 20 test $0x20,%al <== NOT EXECUTED 10852a: 75 0e jne 10853a <== NOT EXECUTED 10852c: 8b 86 94 00 00 00 mov 0x94(%esi),%eax <== NOT EXECUTED 108532: 85 c0 test %eax,%eax <== NOT EXECUTED 108534: 0f 85 a2 fe ff ff jne 1083dc <== 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; 10853a: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108540: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 108543: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED (*tty->device.write)(tty->minor, 108549: 50 push %eax <== NOT EXECUTED 10854a: 6a 01 push $0x1 <== NOT EXECUTED 10854c: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 10854f: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 108552: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED 108558: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10855b: e9 7c fe ff ff jmp 1083dc <== NOT EXECUTED 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS ) ) { tty->flow_ctrl |= FL_IRTSOFF; 108560: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108566: 83 c8 04 or $0x4,%eax <== NOT EXECUTED 108569: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED /* deactivate RTS line */ if (tty->device.stopRemoteTx != NULL) { 10856f: 8b 86 ac 00 00 00 mov 0xac(%esi),%eax <== NOT EXECUTED 108575: 85 c0 test %eax,%eax <== NOT EXECUTED 108577: 0f 84 5f fe ff ff je 1083dc <== NOT EXECUTED tty->device.stopRemoteTx(tty->minor); 10857d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108580: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 108583: ff d0 call *%eax <== NOT EXECUTED 108585: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108588: e9 4f fe ff ff jmp 1083dc <== NOT EXECUTED =============================================================================== 00107f9c : struct rtems_termios_tty *rtems_termios_ttyTail; rtems_id rtems_termios_ttyMutex; void rtems_termios_initialize (void) { 107f9c: 55 push %ebp 107f9d: 89 e5 mov %esp,%ebp 107f9f: 83 ec 08 sub $0x8,%esp rtems_status_code sc; /* * Create the mutex semaphore for the tty list */ if (!rtems_termios_ttyMutex) { 107fa2: a1 8c e5 11 00 mov 0x11e58c,%eax 107fa7: 85 c0 test %eax,%eax 107fa9: 74 05 je 107fb0 <== ALWAYS TAKEN RTEMS_NO_PRIORITY, &rtems_termios_ttyMutex); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } } 107fab: c9 leave 107fac: c3 ret 107fad: 8d 76 00 lea 0x0(%esi),%esi /* * Create the mutex semaphore for the tty list */ if (!rtems_termios_ttyMutex) { sc = rtems_semaphore_create ( 107fb0: 83 ec 0c sub $0xc,%esp 107fb3: 68 8c e5 11 00 push $0x11e58c 107fb8: 6a 00 push $0x0 107fba: 6a 54 push $0x54 107fbc: 6a 01 push $0x1 107fbe: 68 69 6d 52 54 push $0x54526d69 107fc3: e8 a8 21 00 00 call 10a170 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) 107fc8: 83 c4 20 add $0x20,%esp 107fcb: 85 c0 test %eax,%eax 107fcd: 74 dc je 107fab <== ALWAYS TAKEN rtems_fatal_error_occurred (sc); 107fcf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107fd2: 50 push %eax <== NOT EXECUTED 107fd3: e8 ac 2a 00 00 call 10aa84 <== NOT EXECUTED =============================================================================== 00109060 : } } rtems_status_code rtems_termios_ioctl (void *arg) { 109060: 55 push %ebp <== NOT EXECUTED 109061: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109063: 57 push %edi <== NOT EXECUTED 109064: 56 push %esi <== NOT EXECUTED 109065: 53 push %ebx <== NOT EXECUTED 109066: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED rtems_libio_ioctl_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 109069: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10906c: 8b 02 mov (%edx),%eax <== NOT EXECUTED 10906e: 8b 58 28 mov 0x28(%eax),%ebx <== NOT EXECUTED struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer; 109071: 8b 72 08 mov 0x8(%edx),%esi <== NOT EXECUTED rtems_status_code sc; args->ioctl_return = 0; 109074: c7 42 0c 00 00 00 00 movl $0x0,0xc(%edx) <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 10907b: 6a 00 push $0x0 <== NOT EXECUTED 10907d: 6a 00 push $0x0 <== NOT EXECUTED 10907f: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 109082: e8 69 13 00 00 call 10a3f0 <== NOT EXECUTED 109087: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) { 10908a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10908d: 85 c0 test %eax,%eax <== NOT EXECUTED 10908f: 75 4b jne 1090dc <== NOT EXECUTED args->ioctl_return = sc; return sc; } switch (args->command) { 109091: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 109094: 8b 47 04 mov 0x4(%edi),%eax <== NOT EXECUTED 109097: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 10909a: 0f 84 8c 00 00 00 je 10912c <== NOT EXECUTED 1090a0: 77 4e ja 1090f0 <== NOT EXECUTED 1090a2: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 1090a5: 0f 84 71 01 00 00 je 10921c <== NOT EXECUTED 1090ab: 0f 86 27 01 00 00 jbe 1091d8 <== NOT EXECUTED if (tty->device.setAttributes) (*tty->device.setAttributes)(tty->minor, &tty->termios); break; case RTEMS_IO_TCDRAIN: drainOutput (tty); 1090b1: 89 d8 mov %ebx,%eax <== NOT EXECUTED 1090b3: e8 9c fb ff ff call 108c54 <== NOT EXECUTED /* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; } break; } rtems_semaphore_release (tty->osem); 1090b8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1090bb: ff 73 18 pushl 0x18(%ebx) <== NOT EXECUTED 1090be: e8 25 14 00 00 call 10a4e8 <== NOT EXECUTED args->ioctl_return = sc; 1090c3: 8b 55 d4 mov -0x2c(%ebp),%edx <== NOT EXECUTED 1090c6: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 1090c9: 89 50 0c mov %edx,0xc(%eax) <== NOT EXECUTED 1090cc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return sc; } 1090cf: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 1090d2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1090d5: 5b pop %ebx <== NOT EXECUTED 1090d6: 5e pop %esi <== NOT EXECUTED 1090d7: 5f pop %edi <== NOT EXECUTED 1090d8: c9 leave <== NOT EXECUTED 1090d9: c3 ret <== NOT EXECUTED 1090da: 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; 1090dc: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1090df: 89 41 0c mov %eax,0xc(%ecx) <== NOT EXECUTED break; } rtems_semaphore_release (tty->osem); args->ioctl_return = sc; return sc; } 1090e2: 8b 45 d4 mov -0x2c(%ebp),%eax <== NOT EXECUTED 1090e5: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1090e8: 5b pop %ebx <== NOT EXECUTED 1090e9: 5e pop %esi <== NOT EXECUTED 1090ea: 5f pop %edi <== NOT EXECUTED 1090eb: c9 leave <== NOT EXECUTED 1090ec: c3 ret <== NOT EXECUTED 1090ed: 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) { 1090f0: 3d 7f 66 04 40 cmp $0x4004667f,%eax <== NOT EXECUTED 1090f5: 0f 84 fd 00 00 00 je 1091f8 <== NOT EXECUTED 1090fb: 77 5f ja 10915c <== NOT EXECUTED 1090fd: 83 f8 05 cmp $0x5,%eax <== NOT EXECUTED 109100: 74 42 je 109144 <== NOT EXECUTED default: if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) { 109102: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 109108: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 10910b: 8b 80 d8 e2 11 00 mov 0x11e2d8(%eax),%eax <== NOT EXECUTED 109111: 85 c0 test %eax,%eax <== NOT EXECUTED 109113: 0f 84 ab 02 00 00 je 1093c4 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args); 109119: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10911c: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 10911f: 53 push %ebx <== NOT EXECUTED 109120: ff d0 call *%eax <== NOT EXECUTED 109122: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED 109125: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109128: eb 8e jmp 1090b8 <== NOT EXECUTED 10912a: 66 90 xchg %ax,%ax <== NOT EXECUTED case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; break; case RTEMS_IO_RCVWAKEUP: tty->tty_rcv = *wakeup; 10912c: 8b 16 mov (%esi),%edx <== NOT EXECUTED 10912e: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 109131: 89 83 e0 00 00 00 mov %eax,0xe0(%ebx) <== NOT EXECUTED 109137: 89 93 dc 00 00 00 mov %edx,0xdc(%ebx) <== NOT EXECUTED 10913d: e9 76 ff ff ff jmp 1090b8 <== NOT EXECUTED 109142: 66 90 xchg %ax,%ax <== NOT EXECUTED case RTEMS_IO_TCDRAIN: drainOutput (tty); break; case RTEMS_IO_SNDWAKEUP: tty->tty_snd = *wakeup; 109144: 8b 16 mov (%esi),%edx <== NOT EXECUTED 109146: 8b 46 04 mov 0x4(%esi),%eax <== NOT EXECUTED 109149: 89 83 d8 00 00 00 mov %eax,0xd8(%ebx) <== NOT EXECUTED 10914f: 89 93 d4 00 00 00 mov %edx,0xd4(%ebx) <== NOT EXECUTED 109155: e9 5e ff ff ff jmp 1090b8 <== NOT EXECUTED 10915a: 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) { 10915c: 3d 1a 74 04 40 cmp $0x4004741a,%eax <== NOT EXECUTED 109161: 74 61 je 1091c4 <== NOT EXECUTED 109163: 3d 1b 74 04 80 cmp $0x8004741b,%eax <== NOT EXECUTED 109168: 75 98 jne 109102 <== NOT EXECUTED #if 1 /* FIXME */ case TIOCSETD: /* * close old line discipline */ if (rtems_termios_linesw[tty->t_line].l_close != NULL) { 10916a: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 109170: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 109173: 8b 80 c4 e2 11 00 mov 0x11e2c4(%eax),%eax <== NOT EXECUTED 109179: 85 c0 test %eax,%eax <== NOT EXECUTED 10917b: 74 0c je 109189 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_close(tty); 10917d: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109180: 53 push %ebx <== NOT EXECUTED 109181: ff d0 call *%eax <== NOT EXECUTED 109183: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED 109186: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } tty->t_line=*(int*)(args->buffer); 109189: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 10918c: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 10918f: 8b 00 mov (%eax),%eax <== NOT EXECUTED 109191: 89 83 cc 00 00 00 mov %eax,0xcc(%ebx) <== NOT EXECUTED tty->t_sc = NULL; /* ensure that no more valid data */ 109197: c7 83 d0 00 00 00 00 movl $0x0,0xd0(%ebx) <== NOT EXECUTED 10919e: 00 00 00 /* * open new line discipline */ if (rtems_termios_linesw[tty->t_line].l_open != NULL) { 1091a1: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 1091a4: 8b 80 c0 e2 11 00 mov 0x11e2c0(%eax),%eax <== NOT EXECUTED 1091aa: 85 c0 test %eax,%eax <== NOT EXECUTED 1091ac: 0f 84 06 ff ff ff je 1090b8 <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_open(tty); 1091b2: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1091b5: 53 push %ebx <== NOT EXECUTED 1091b6: ff d0 call *%eax <== NOT EXECUTED 1091b8: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED 1091bb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1091be: e9 f5 fe ff ff jmp 1090b8 <== NOT EXECUTED 1091c3: 90 nop <== NOT EXECUTED } break; case TIOCGETD: *(int*)(args->buffer)=tty->t_line; 1091c4: 8b 4d 08 mov 0x8(%ebp),%ecx <== NOT EXECUTED 1091c7: 8b 51 08 mov 0x8(%ecx),%edx <== NOT EXECUTED 1091ca: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 1091d0: 89 02 mov %eax,(%edx) <== NOT EXECUTED 1091d2: e9 e1 fe ff ff jmp 1090b8 <== NOT EXECUTED 1091d7: 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) { 1091d8: 48 dec %eax <== NOT EXECUTED 1091d9: 0f 85 23 ff ff ff jne 109102 <== NOT EXECUTED sc = RTEMS_INVALID_NUMBER; } break; case RTEMS_IO_GET_ATTRIBUTES: *(struct termios *)args->buffer = tty->termios; 1091df: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 1091e2: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 1091e5: 8d 73 30 lea 0x30(%ebx),%esi <== NOT EXECUTED 1091e8: b9 09 00 00 00 mov $0x9,%ecx <== NOT EXECUTED 1091ed: 89 c7 mov %eax,%edi <== NOT EXECUTED 1091ef: f3 a5 rep movsl %ds:(%esi),%es:(%edi) <== NOT EXECUTED 1091f1: e9 c2 fe ff ff jmp 1090b8 <== NOT EXECUTED 1091f6: 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; 1091f8: 8b 53 60 mov 0x60(%ebx),%edx <== NOT EXECUTED 1091fb: 8b 43 5c mov 0x5c(%ebx),%eax <== NOT EXECUTED if ( rawnc < 0 ) 1091fe: 29 c2 sub %eax,%edx <== NOT EXECUTED 109200: 0f 88 b2 01 00 00 js 1093b8 <== NOT EXECUTED rawnc += tty->rawInBuf.Size; /* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; 109206: 8b 7d 08 mov 0x8(%ebp),%edi <== NOT EXECUTED 109209: 8b 47 08 mov 0x8(%edi),%eax <== NOT EXECUTED 10920c: 03 53 20 add 0x20(%ebx),%edx <== NOT EXECUTED 10920f: 2b 53 24 sub 0x24(%ebx),%edx <== NOT EXECUTED 109212: 89 10 mov %edx,(%eax) <== NOT EXECUTED 109214: e9 9f fe ff ff jmp 1090b8 <== NOT EXECUTED 109219: 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; 10921c: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 10921f: 8b 70 08 mov 0x8(%eax),%esi <== NOT EXECUTED 109222: 8d 53 30 lea 0x30(%ebx),%edx <== NOT EXECUTED 109225: 89 55 d8 mov %edx,-0x28(%ebp) <== NOT EXECUTED 109228: b9 09 00 00 00 mov $0x9,%ecx <== NOT EXECUTED 10922d: 89 d7 mov %edx,%edi <== NOT EXECUTED 10922f: 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) && 109231: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109237: f6 c4 02 test $0x2,%ah <== NOT EXECUTED 10923a: 74 44 je 109280 <== NOT EXECUTED 10923c: f6 43 31 04 testb $0x4,0x31(%ebx) <== NOT EXECUTED 109240: 75 3e jne 109280 <== NOT EXECUTED !(tty->termios.c_iflag & IXON)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF); 109242: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109248: 25 ef fd ff ff and $0xfffffdef,%eax <== NOT EXECUTED 10924d: 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) { 109253: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109259: a8 20 test $0x20,%al <== NOT EXECUTED 10925b: 74 23 je 109280 <== NOT EXECUTED /* disable interrupts */ rtems_interrupt_disable(level); 10925d: 9c pushf <== NOT EXECUTED 10925e: fa cli <== NOT EXECUTED 10925f: 5e pop %esi <== NOT EXECUTED tty->flow_ctrl &= ~FL_OSTOP; 109260: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109266: 83 e0 df and $0xffffffdf,%eax <== NOT EXECUTED 109269: 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) { 10926f: 8b 8b 94 00 00 00 mov 0x94(%ebx),%ecx <== NOT EXECUTED 109275: 85 c9 test %ecx,%ecx <== NOT EXECUTED 109277: 0f 85 7d 01 00 00 jne 1093fa <== 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); 10927d: 56 push %esi <== NOT EXECUTED 10927e: 9d popf <== NOT EXECUTED 10927f: 90 nop <== NOT EXECUTED } } /* check for incoming XON/XOFF flow control switched off */ if (( tty->flow_ctrl & FL_MDXOF) && 109280: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109286: f6 c4 04 test $0x4,%ah <== NOT EXECUTED 109289: 74 24 je 1092af <== NOT EXECUTED 10928b: f6 43 31 10 testb $0x10,0x31(%ebx) <== NOT EXECUTED 10928f: 75 1e jne 1092af <== NOT EXECUTED !(tty->termios.c_iflag & IXOFF)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDXOF); 109291: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 109297: 80 e4 fb and $0xfb,%ah <== NOT EXECUTED 10929a: 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); 1092a0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1092a6: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 1092a9: 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) && 1092af: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1092b5: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 1092b8: 74 48 je 109302 <== NOT EXECUTED 1092ba: 8b 7b 38 mov 0x38(%ebx),%edi <== NOT EXECUTED 1092bd: 85 ff test %edi,%edi <== NOT EXECUTED 1092bf: 0f 88 0b 01 00 00 js 1093d0 <== NOT EXECUTED !(tty->termios.c_cflag & CRTSCTS)) { /* clear related flags in flow_ctrl */ tty->flow_ctrl &= ~(FL_MDRTS); 1092c5: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1092cb: 80 e4 fe and $0xfe,%ah <== NOT EXECUTED 1092ce: 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) && 1092d4: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1092da: a8 04 test $0x4,%al <== NOT EXECUTED 1092dc: 74 15 je 1092f3 <== NOT EXECUTED 1092de: 8b 83 b0 00 00 00 mov 0xb0(%ebx),%eax <== NOT EXECUTED 1092e4: 85 c0 test %eax,%eax <== NOT EXECUTED 1092e6: 74 0b je 1092f3 <== NOT EXECUTED (tty->device.startRemoteTx != NULL)) { tty->device.startRemoteTx(tty->minor); 1092e8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 1092eb: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1092ee: ff d0 call *%eax <== NOT EXECUTED 1092f0: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } tty->flow_ctrl &= ~(FL_IRTSOFF); 1092f3: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1092f9: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 1092fc: 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) { 109302: 8b 73 38 mov 0x38(%ebx),%esi <== NOT EXECUTED 109305: 85 f6 test %esi,%esi <== NOT EXECUTED 109307: 0f 88 c3 00 00 00 js 1093d0 <== NOT EXECUTED tty->flow_ctrl |= FL_MDRTS; } /* check for incoming XON/XOF flow control switched on */ if (tty->termios.c_iflag & IXOFF) { 10930d: 8b 53 30 mov 0x30(%ebx),%edx <== NOT EXECUTED 109310: f6 c6 10 test $0x10,%dh <== NOT EXECUTED 109313: 74 0f je 109324 <== NOT EXECUTED tty->flow_ctrl |= FL_MDXOF; 109315: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10931b: 80 cc 04 or $0x4,%ah <== NOT EXECUTED 10931e: 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) { 109324: 80 e6 04 and $0x4,%dh <== NOT EXECUTED 109327: 74 0f je 109338 <== NOT EXECUTED tty->flow_ctrl |= FL_MDXON; 109329: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 10932f: 80 cc 02 or $0x2,%ah <== NOT EXECUTED 109332: 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) { 109338: f6 43 3c 02 testb $0x2,0x3c(%ebx) <== NOT EXECUTED 10933c: 74 36 je 109374 <== NOT EXECUTED else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; } else { if (tty->termios.c_cc[VMIN]) { tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 10933e: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; 109345: c7 43 70 00 00 00 00 movl $0x0,0x70(%ebx) <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; 10934c: c7 43 74 00 00 00 00 movl $0x0,0x74(%ebx) <== NOT EXECUTED else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; } } } if (tty->device.setAttributes) 109353: 8b 83 a8 00 00 00 mov 0xa8(%ebx),%eax <== NOT EXECUTED 109359: 85 c0 test %eax,%eax <== NOT EXECUTED 10935b: 0f 84 57 fd ff ff je 1090b8 <== NOT EXECUTED (*tty->device.setAttributes)(tty->minor, &tty->termios); 109361: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109364: ff 75 d8 pushl -0x28(%ebp) <== NOT EXECUTED 109367: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10936a: ff d0 call *%eax <== NOT EXECUTED 10936c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10936f: e9 44 fd ff ff jmp 1090b8 <== 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); 109374: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109377: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 10937a: 50 push %eax <== NOT EXECUTED 10937b: 6a 03 push $0x3 <== NOT EXECUTED 10937d: e8 8e 07 00 00 call 109b10 <== NOT EXECUTED tty->vtimeTicks = tty->termios.c_cc[VTIME] * ticksPerSecond / 10; 109382: 0f b6 43 46 movzbl 0x46(%ebx),%eax <== NOT EXECUTED 109386: 0f af 45 f0 imul -0x10(%ebp),%eax <== NOT EXECUTED 10938a: ba cd cc cc cc mov $0xcccccccd,%edx <== NOT EXECUTED 10938f: f7 e2 mul %edx <== NOT EXECUTED 109391: c1 ea 03 shr $0x3,%edx <== NOT EXECUTED 109394: 89 53 54 mov %edx,0x54(%ebx) <== NOT EXECUTED if (tty->termios.c_cc[VTIME]) { 109397: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10939a: 80 7b 46 00 cmpb $0x0,0x46(%ebx) <== NOT EXECUTED 10939e: 74 44 je 1093e4 <== NOT EXECUTED tty->rawInBufSemaphoreOptions = RTEMS_WAIT; 1093a0: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx) <== NOT EXECUTED tty->rawInBufSemaphoreTimeout = tty->vtimeTicks; 1093a7: 89 53 70 mov %edx,0x70(%ebx) <== NOT EXECUTED if (tty->termios.c_cc[VMIN]) 1093aa: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED 1093ae: 75 9c jne 10934c <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; 1093b0: 89 53 74 mov %edx,0x74(%ebx) <== NOT EXECUTED 1093b3: eb 9e jmp 109353 <== NOT EXECUTED 1093b5: 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; 1093b8: 8b 43 64 mov 0x64(%ebx),%eax <== NOT EXECUTED 1093bb: 01 c2 add %eax,%edx <== NOT EXECUTED 1093bd: e9 44 fe ff ff jmp 109206 <== NOT EXECUTED 1093c2: 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) { 1093c4: c7 45 d4 0a 00 00 00 movl $0xa,-0x2c(%ebp) <== NOT EXECUTED 1093cb: e9 e8 fc ff ff jmp 1090b8 <== 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; 1093d0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1093d6: 80 cc 01 or $0x1,%ah <== NOT EXECUTED 1093d9: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED 1093df: e9 29 ff ff ff jmp 10930d <== NOT EXECUTED tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; else tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks; } else { if (tty->termios.c_cc[VMIN]) { 1093e4: 80 7b 47 00 cmpb $0x0,0x47(%ebx) <== NOT EXECUTED 1093e8: 0f 85 50 ff ff ff jne 10933e <== NOT EXECUTED tty->rawInBufSemaphoreOptions = RTEMS_WAIT; tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT; } else { tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT; 1093ee: c7 43 6c 01 00 00 00 movl $0x1,0x6c(%ebx) <== NOT EXECUTED 1093f5: e9 59 ff ff ff jmp 109353 <== 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, 1093fa: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax <== NOT EXECUTED 109400: 52 push %edx <== NOT EXECUTED 109401: 6a 01 push $0x1 <== NOT EXECUTED 109403: 03 43 7c add 0x7c(%ebx),%eax <== NOT EXECUTED 109406: 50 push %eax <== NOT EXECUTED 109407: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 10940a: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED 109410: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109413: e9 65 fe ff ff jmp 10927d <== NOT EXECUTED =============================================================================== 001095cc : rtems_device_major_number major, rtems_device_minor_number minor, void *arg, const rtems_termios_callbacks *callbacks ) { 1095cc: 55 push %ebp 1095cd: 89 e5 mov %esp,%ebp 1095cf: 57 push %edi 1095d0: 56 push %esi 1095d1: 53 push %ebx 1095d2: 83 ec 10 sub $0x10,%esp struct rtems_termios_tty *tty; /* * See if the device has already been opened */ sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, 1095d5: 6a 00 push $0x0 1095d7: 6a 00 push $0x0 1095d9: ff 35 8c e5 11 00 pushl 0x11e58c 1095df: e8 0c 0e 00 00 call 10a3f0 1095e4: 89 45 f0 mov %eax,-0x10(%ebp) RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 1095e7: 83 c4 10 add $0x10,%esp 1095ea: 85 c0 test %eax,%eax 1095ec: 75 6e jne 10965c <== NEVER TAKEN return sc; for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) { 1095ee: 8b 1d 94 e5 11 00 mov 0x11e594,%ebx 1095f4: 85 db test %ebx,%ebx 1095f6: 75 0a jne 109602 1095f8: eb 6e jmp 109668 1095fa: 66 90 xchg %ax,%ax 1095fc: 8b 1b mov (%ebx),%ebx <== NOT EXECUTED 1095fe: 85 db test %ebx,%ebx <== NOT EXECUTED 109600: 74 66 je 109668 <== NOT EXECUTED if ((tty->major == major) && (tty->minor == minor)) 109602: 8b 45 08 mov 0x8(%ebp),%eax 109605: 39 43 0c cmp %eax,0xc(%ebx) 109608: 75 f2 jne 1095fc <== NEVER TAKEN 10960a: 8b 55 0c mov 0xc(%ebp),%edx 10960d: 39 53 10 cmp %edx,0x10(%ebx) 109610: 75 ea jne 1095fc <== NEVER TAKEN */ if (c++ == 'z') c = 'a'; } args->iop->data1 = tty; 109612: 8b 7d 10 mov 0x10(%ebp),%edi 109615: 8b 07 mov (%edi),%eax 109617: 89 58 28 mov %ebx,0x28(%eax) if (!tty->refcount++) { 10961a: 8b 53 08 mov 0x8(%ebx),%edx 10961d: 8d 42 01 lea 0x1(%edx),%eax 109620: 89 43 08 mov %eax,0x8(%ebx) 109623: 85 d2 test %edx,%edx 109625: 75 24 jne 10964b if (tty->device.firstOpen) 109627: 8b 83 98 00 00 00 mov 0x98(%ebx),%eax 10962d: 85 c0 test %eax,%eax 10962f: 74 0d je 10963e <== NEVER TAKEN (*tty->device.firstOpen)(major, minor, arg); 109631: 52 push %edx 109632: 57 push %edi 109633: ff 75 0c pushl 0xc(%ebp) 109636: ff 75 08 pushl 0x8(%ebp) 109639: ff d0 call *%eax 10963b: 83 c4 10 add $0x10,%esp /* * start I/O tasks, if needed */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 10963e: 83 bb b4 00 00 00 02 cmpl $0x2,0xb4(%ebx) 109645: 0f 84 8d 02 00 00 je 1098d8 <== NEVER TAKEN (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } } rtems_semaphore_release (rtems_termios_ttyMutex); 10964b: 83 ec 0c sub $0xc,%esp 10964e: ff 35 8c e5 11 00 pushl 0x11e58c 109654: e8 8f 0e 00 00 call 10a4e8 109659: 83 c4 10 add $0x10,%esp return RTEMS_SUCCESSFUL; } 10965c: 8b 45 f0 mov -0x10(%ebp),%eax 10965f: 8d 65 f4 lea -0xc(%ebp),%esp 109662: 5b pop %ebx 109663: 5e pop %esi 109664: 5f pop %edi 109665: c9 leave 109666: c3 ret 109667: 90 nop static char c = 'a'; /* * Create a new device */ tty = calloc (1, sizeof (struct rtems_termios_tty)); 109668: 83 ec 08 sub $0x8,%esp 10966b: 68 e8 00 00 00 push $0xe8 109670: 6a 01 push $0x1 109672: e8 45 4e 00 00 call 10e4bc 109677: 89 45 e8 mov %eax,-0x18(%ebp) 10967a: 89 c3 mov %eax,%ebx if (tty == NULL) { 10967c: 83 c4 10 add $0x10,%esp 10967f: 85 c0 test %eax,%eax 109681: 0f 84 b5 02 00 00 je 10993c <== NEVER TAKEN return RTEMS_NO_MEMORY; } /* * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; 109687: a1 88 c4 11 00 mov 0x11c488,%eax 10968c: 8b 75 e8 mov -0x18(%ebp),%esi 10968f: 89 46 64 mov %eax,0x64(%esi) tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size); 109692: 8b 46 64 mov 0x64(%esi),%eax 109695: 83 ec 0c sub $0xc,%esp 109698: 50 push %eax 109699: e8 3a dc ff ff call 1072d8 10969e: 89 46 58 mov %eax,0x58(%esi) if (tty->rawInBuf.theBuf == NULL) { 1096a1: 83 c4 10 add $0x10,%esp 1096a4: 85 c0 test %eax,%eax 1096a6: 0f 84 6b 02 00 00 je 109917 <== NEVER TAKEN return RTEMS_NO_MEMORY; } /* * allocate raw output buffer */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; 1096ac: a1 8c c4 11 00 mov 0x11c48c,%eax 1096b1: 8b 7d e8 mov -0x18(%ebp),%edi 1096b4: 89 87 88 00 00 00 mov %eax,0x88(%edi) tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size); 1096ba: 8b 87 88 00 00 00 mov 0x88(%edi),%eax 1096c0: 83 ec 0c sub $0xc,%esp 1096c3: 50 push %eax 1096c4: e8 0f dc ff ff call 1072d8 1096c9: 89 47 7c mov %eax,0x7c(%edi) if (tty->rawOutBuf.theBuf == NULL) { 1096cc: 83 c4 10 add $0x10,%esp 1096cf: 85 c0 test %eax,%eax 1096d1: 0f 84 82 02 00 00 je 109959 <== NEVER TAKEN return RTEMS_NO_MEMORY; } /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); 1096d7: 83 ec 0c sub $0xc,%esp 1096da: ff 35 84 c4 11 00 pushl 0x11c484 1096e0: e8 f3 db ff ff call 1072d8 1096e5: 8b 55 e8 mov -0x18(%ebp),%edx 1096e8: 89 42 1c mov %eax,0x1c(%edx) if (tty->cbuf == NULL) { 1096eb: 83 c4 10 add $0x10,%esp 1096ee: 85 c0 test %eax,%eax 1096f0: 0f 84 a6 02 00 00 je 10999c <== NEVER TAKEN return RTEMS_NO_MEMORY; } /* * Initialize wakeup callbacks */ tty->tty_snd.sw_pfn = NULL; 1096f6: 8b 7d e8 mov -0x18(%ebp),%edi 1096f9: c7 87 d4 00 00 00 00 movl $0x0,0xd4(%edi) 109700: 00 00 00 tty->tty_snd.sw_arg = NULL; 109703: c7 87 d8 00 00 00 00 movl $0x0,0xd8(%edi) 10970a: 00 00 00 tty->tty_rcv.sw_pfn = NULL; 10970d: c7 87 dc 00 00 00 00 movl $0x0,0xdc(%edi) 109714: 00 00 00 tty->tty_rcv.sw_arg = NULL; 109717: c7 87 e0 00 00 00 00 movl $0x0,0xe0(%edi) 10971e: 00 00 00 tty->tty_rcvwakeup = 0; 109721: c7 87 e4 00 00 00 00 movl $0x0,0xe4(%edi) 109728: 00 00 00 /* * link tty */ tty->forw = rtems_termios_ttyHead; 10972b: a1 94 e5 11 00 mov 0x11e594,%eax 109730: 89 07 mov %eax,(%edi) tty->back = NULL; 109732: c7 47 04 00 00 00 00 movl $0x0,0x4(%edi) if (rtems_termios_ttyHead != NULL) 109739: 85 c0 test %eax,%eax 10973b: 74 03 je 109740 <== ALWAYS TAKEN rtems_termios_ttyHead->back = tty; 10973d: 89 78 04 mov %edi,0x4(%eax) <== NOT EXECUTED rtems_termios_ttyHead = tty; 109740: 8b 45 e8 mov -0x18(%ebp),%eax 109743: a3 94 e5 11 00 mov %eax,0x11e594 if (rtems_termios_ttyTail == NULL) 109748: 8b 35 90 e5 11 00 mov 0x11e590,%esi 10974e: 85 f6 test %esi,%esi 109750: 0f 84 d6 02 00 00 je 109a2c <== ALWAYS TAKEN rtems_termios_ttyTail = tty; tty->minor = minor; 109756: 8b 75 0c mov 0xc(%ebp),%esi 109759: 8b 55 e8 mov -0x18(%ebp),%edx 10975c: 89 72 10 mov %esi,0x10(%edx) tty->major = major; 10975f: 8b 7d 08 mov 0x8(%ebp),%edi 109762: 89 7a 0c mov %edi,0xc(%edx) /* * Set up mutex semaphores */ sc = rtems_semaphore_create ( 109765: 83 ec 0c sub $0xc,%esp 109768: 89 d0 mov %edx,%eax 10976a: 83 c0 14 add $0x14,%eax 10976d: 50 push %eax 10976e: 6a 00 push $0x0 109770: 6a 54 push $0x54 109772: 6a 01 push $0x1 109774: 0f be 05 90 c4 11 00 movsbl 0x11c490,%eax 10977b: 0d 00 69 52 54 or $0x54526900,%eax 109780: 50 push %eax 109781: e8 ea 09 00 00 call 10a170 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) 109786: 83 c4 20 add $0x20,%esp 109789: 85 c0 test %eax,%eax 10978b: 0f 85 7d 01 00 00 jne 10990e <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 109791: 83 ec 0c sub $0xc,%esp 109794: 8b 45 e8 mov -0x18(%ebp),%eax 109797: 83 c0 18 add $0x18,%eax 10979a: 50 push %eax 10979b: 6a 00 push $0x0 10979d: 6a 54 push $0x54 10979f: 6a 01 push $0x1 1097a1: 0f be 05 90 c4 11 00 movsbl 0x11c490,%eax 1097a8: 0d 00 6f 52 54 or $0x54526f00,%eax 1097ad: 50 push %eax 1097ae: e8 bd 09 00 00 call 10a170 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) 1097b3: 83 c4 20 add $0x20,%esp 1097b6: 85 c0 test %eax,%eax 1097b8: 0f 85 50 01 00 00 jne 10990e <== NEVER TAKEN rtems_fatal_error_occurred (sc); sc = rtems_semaphore_create ( 1097be: 83 ec 0c sub $0xc,%esp 1097c1: 8b 45 e8 mov -0x18(%ebp),%eax 1097c4: 05 8c 00 00 00 add $0x8c,%eax 1097c9: 50 push %eax 1097ca: 6a 00 push $0x0 1097cc: 6a 20 push $0x20 1097ce: 6a 00 push $0x0 1097d0: 0f be 05 90 c4 11 00 movsbl 0x11c490,%eax 1097d7: 0d 00 78 52 54 or $0x54527800,%eax 1097dc: 50 push %eax 1097dd: e8 8e 09 00 00 call 10a170 rtems_build_name ('T', 'R', 'x', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO, RTEMS_NO_PRIORITY, &tty->rawOutBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 1097e2: 83 c4 20 add $0x20,%esp 1097e5: 85 c0 test %eax,%eax 1097e7: 0f 85 21 01 00 00 jne 10990e <== NEVER TAKEN rtems_fatal_error_occurred (sc); tty->rawOutBufState = rob_idle; 1097ed: 8b 45 e8 mov -0x18(%ebp),%eax 1097f0: c7 80 94 00 00 00 00 movl $0x0,0x94(%eax) 1097f7: 00 00 00 /* * Set callbacks */ tty->device = *callbacks; 1097fa: 05 98 00 00 00 add $0x98,%eax 1097ff: b9 08 00 00 00 mov $0x8,%ecx 109804: 89 c7 mov %eax,%edi 109806: 8b 75 14 mov 0x14(%ebp),%esi 109809: f3 a5 rep movsl %ds:(%esi),%es:(%edi) /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { 10980b: 8b 45 e8 mov -0x18(%ebp),%eax 10980e: 83 b8 b4 00 00 00 02 cmpl $0x2,0xb4(%eax) 109815: 0f 84 a0 01 00 00 je 1099bb <== NEVER TAKEN &tty->rxTaskId); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || 10981b: 8b 55 e8 mov -0x18(%ebp),%edx 10981e: 8b 8a a0 00 00 00 mov 0xa0(%edx),%ecx 109824: 85 c9 test %ecx,%ecx 109826: 0f 84 3d 01 00 00 je 109969 <== ALWAYS TAKEN 10982c: 83 ba b4 00 00 00 02 cmpl $0x2,0xb4(%edx) <== NOT EXECUTED 109833: 0f 84 30 01 00 00 je 109969 <== NOT EXECUTED } /* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; 109839: 8b 75 e8 mov -0x18(%ebp),%esi 10983c: c7 46 30 02 25 00 00 movl $0x2502,0x30(%esi) tty->termios.c_oflag = OPOST | ONLCR | XTABS; 109843: c7 46 34 05 18 00 00 movl $0x1805,0x34(%esi) tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; 10984a: c7 46 38 bd 08 00 00 movl $0x8bd,0x38(%esi) tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL; 109851: c7 46 3c 3b 82 00 00 movl $0x823b,0x3c(%esi) tty->termios.c_cc[VINTR] = '\003'; 109858: c6 46 41 03 movb $0x3,0x41(%esi) tty->termios.c_cc[VQUIT] = '\034'; 10985c: c6 46 42 1c movb $0x1c,0x42(%esi) tty->termios.c_cc[VERASE] = '\177'; 109860: c6 46 43 7f movb $0x7f,0x43(%esi) tty->termios.c_cc[VKILL] = '\025'; 109864: c6 46 44 15 movb $0x15,0x44(%esi) tty->termios.c_cc[VEOF] = '\004'; 109868: c6 46 45 04 movb $0x4,0x45(%esi) tty->termios.c_cc[VEOL] = '\000'; 10986c: c6 46 4c 00 movb $0x0,0x4c(%esi) tty->termios.c_cc[VEOL2] = '\000'; 109870: c6 46 51 00 movb $0x0,0x51(%esi) tty->termios.c_cc[VSTART] = '\021'; 109874: c6 46 49 11 movb $0x11,0x49(%esi) tty->termios.c_cc[VSTOP] = '\023'; 109878: c6 46 4a 13 movb $0x13,0x4a(%esi) tty->termios.c_cc[VSUSP] = '\032'; 10987c: c6 46 4b 1a movb $0x1a,0x4b(%esi) tty->termios.c_cc[VREPRINT] = '\022'; 109880: c6 46 4d 12 movb $0x12,0x4d(%esi) tty->termios.c_cc[VDISCARD] = '\017'; 109884: c6 46 4e 0f movb $0xf,0x4e(%esi) tty->termios.c_cc[VWERASE] = '\027'; 109888: c6 46 4f 17 movb $0x17,0x4f(%esi) tty->termios.c_cc[VLNEXT] = '\026'; 10988c: c6 46 50 16 movb $0x16,0x50(%esi) /* start with no flow control, clear flow control flags */ tty->flow_ctrl = 0; 109890: c7 86 b8 00 00 00 00 movl $0x0,0xb8(%esi) 109897: 00 00 00 /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2; 10989a: 8b 46 64 mov 0x64(%esi),%eax 10989d: d1 e8 shr %eax 10989f: 89 86 bc 00 00 00 mov %eax,0xbc(%esi) tty->highwater = tty->rawInBuf.Size * 3/4; 1098a5: 8b 46 64 mov 0x64(%esi),%eax 1098a8: 8d 04 40 lea (%eax,%eax,2),%eax 1098ab: c1 e8 02 shr $0x2,%eax 1098ae: 89 86 c0 00 00 00 mov %eax,0xc0(%esi) /* * Bump name characer */ if (c++ == 'z') 1098b4: 8a 15 90 c4 11 00 mov 0x11c490,%dl 1098ba: 8d 42 01 lea 0x1(%edx),%eax 1098bd: a2 90 c4 11 00 mov %al,0x11c490 1098c2: 80 fa 7a cmp $0x7a,%dl 1098c5: 0f 85 47 fd ff ff jne 109612 <== ALWAYS TAKEN c = 'a'; 1098cb: c6 05 90 c4 11 00 61 movb $0x61,0x11c490 <== NOT EXECUTED 1098d2: e9 3b fd ff ff jmp 109612 <== NOT EXECUTED 1098d7: 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, 1098d8: 57 push %edi <== NOT EXECUTED 1098d9: 53 push %ebx <== NOT EXECUTED 1098da: 68 a4 9a 10 00 push $0x109aa4 <== NOT EXECUTED 1098df: ff b3 c4 00 00 00 pushl 0xc4(%ebx) <== NOT EXECUTED 1098e5: e8 3e 0f 00 00 call 10a828 <== NOT EXECUTED rtems_termios_rxdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 1098ea: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 1098ed: 85 c0 test %eax,%eax <== NOT EXECUTED 1098ef: 75 1d jne 10990e <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_task_start(tty->txTaskId, 1098f1: 56 push %esi <== NOT EXECUTED 1098f2: 53 push %ebx <== NOT EXECUTED 1098f3: 68 38 9a 10 00 push $0x109a38 <== NOT EXECUTED 1098f8: ff b3 c8 00 00 00 pushl 0xc8(%ebx) <== NOT EXECUTED 1098fe: e8 25 0f 00 00 call 10a828 <== NOT EXECUTED rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL) 109903: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109906: 85 c0 test %eax,%eax <== NOT EXECUTED 109908: 0f 84 3d fd ff ff je 10964b <== NOT EXECUTED rtems_fatal_error_occurred (sc); 10990e: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109911: 50 push %eax <== NOT EXECUTED 109912: e8 6d 11 00 00 call 10aa84 <== 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); 109917: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10991a: 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); 10991b: e8 a0 d7 ff ff call 1070c0 <== NOT EXECUTED rtems_semaphore_release (rtems_termios_ttyMutex); 109920: 58 pop %eax <== NOT EXECUTED 109921: ff 35 8c e5 11 00 pushl 0x11e58c <== NOT EXECUTED 109927: e8 bc 0b 00 00 call 10a4e8 <== NOT EXECUTED 10992c: c7 45 f0 1a 00 00 00 movl $0x1a,-0x10(%ebp) <== NOT EXECUTED 109933: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109936: e9 21 fd ff ff jmp 10965c <== NOT EXECUTED 10993b: 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); 10993c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10993f: ff 35 8c e5 11 00 pushl 0x11e58c <== NOT EXECUTED 109945: e8 9e 0b 00 00 call 10a4e8 <== NOT EXECUTED 10994a: c7 45 f0 1a 00 00 00 movl $0x1a,-0x10(%ebp) <== NOT EXECUTED 109951: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109954: e9 03 fd ff ff jmp 10965c <== 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)); 109959: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10995c: ff 77 58 pushl 0x58(%edi) <== NOT EXECUTED 10995f: e8 5c d7 ff ff call 1070c0 <== NOT EXECUTED free(tty); 109964: 89 3c 24 mov %edi,(%esp) <== NOT EXECUTED 109967: eb b2 jmp 10991b <== NOT EXECUTED rtems_fatal_error_occurred (sc); } if ((tty->device.pollRead == NULL) || (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){ sc = rtems_semaphore_create ( 109969: 83 ec 0c sub $0xc,%esp 10996c: 8b 45 e8 mov -0x18(%ebp),%eax 10996f: 83 c0 68 add $0x68,%eax 109972: 50 push %eax 109973: 6a 00 push $0x0 109975: 6a 24 push $0x24 109977: 6a 00 push $0x0 109979: 0f be 05 90 c4 11 00 movsbl 0x11c490,%eax 109980: 0d 00 72 52 54 or $0x54527200,%eax 109985: 50 push %eax 109986: e8 e5 07 00 00 call 10a170 rtems_build_name ('T', 'R', 'r', c), 0, RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY, RTEMS_NO_PRIORITY, &tty->rawInBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) 10998b: 83 c4 20 add $0x20,%esp 10998e: 85 c0 test %eax,%eax 109990: 0f 84 a3 fe ff ff je 109839 <== ALWAYS TAKEN 109996: e9 73 ff ff ff jmp 10990e <== NOT EXECUTED 10999b: 90 nop <== NOT EXECUTED /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE); if (tty->cbuf == NULL) { free((void *)(tty->rawOutBuf.theBuf)); 10999c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10999f: ff 72 7c pushl 0x7c(%edx) <== NOT EXECUTED 1099a2: e8 19 d7 ff ff call 1070c0 <== NOT EXECUTED free((void *)(tty->rawInBuf.theBuf)); 1099a7: 5f pop %edi <== NOT EXECUTED 1099a8: 8b 75 e8 mov -0x18(%ebp),%esi <== NOT EXECUTED 1099ab: ff 76 58 pushl 0x58(%esi) <== NOT EXECUTED 1099ae: e8 0d d7 ff ff call 1070c0 <== NOT EXECUTED free(tty); 1099b3: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED 1099b6: e9 60 ff ff ff jmp 10991b <== NOT EXECUTED /* * Create I/O tasks */ if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) { sc = rtems_task_create ( 1099bb: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1099be: 05 c8 00 00 00 add $0xc8,%eax <== NOT EXECUTED 1099c3: 50 push %eax <== NOT EXECUTED 1099c4: 6a 00 push $0x0 <== NOT EXECUTED 1099c6: 68 00 05 00 00 push $0x500 <== NOT EXECUTED 1099cb: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 1099d0: 6a 0a push $0xa <== NOT EXECUTED 1099d2: 0f be 05 90 c4 11 00 movsbl 0x11c490,%eax <== NOT EXECUTED 1099d9: 0d 00 54 78 54 or $0x54785400,%eax <== NOT EXECUTED 1099de: 50 push %eax <== NOT EXECUTED 1099df: e8 a4 0b 00 00 call 10a588 <== 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) 1099e4: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 1099e7: 85 c0 test %eax,%eax <== NOT EXECUTED 1099e9: 0f 85 1f ff ff ff jne 10990e <== NOT EXECUTED rtems_fatal_error_occurred (sc); sc = rtems_task_create ( 1099ef: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 1099f2: 8b 45 e8 mov -0x18(%ebp),%eax <== NOT EXECUTED 1099f5: 05 c4 00 00 00 add $0xc4,%eax <== NOT EXECUTED 1099fa: 50 push %eax <== NOT EXECUTED 1099fb: 6a 00 push $0x0 <== NOT EXECUTED 1099fd: 68 00 05 00 00 push $0x500 <== NOT EXECUTED 109a02: 68 00 04 00 00 push $0x400 <== NOT EXECUTED 109a07: 6a 09 push $0x9 <== NOT EXECUTED 109a09: 0f be 05 90 c4 11 00 movsbl 0x11c490,%eax <== NOT EXECUTED 109a10: 0d 00 54 78 52 or $0x52785400,%eax <== NOT EXECUTED 109a15: 50 push %eax <== NOT EXECUTED 109a16: e8 6d 0b 00 00 call 10a588 <== 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) 109a1b: 83 c4 20 add $0x20,%esp <== NOT EXECUTED 109a1e: 85 c0 test %eax,%eax <== NOT EXECUTED 109a20: 0f 84 f5 fd ff ff je 10981b <== NOT EXECUTED 109a26: e9 e3 fe ff ff jmp 10990e <== NOT EXECUTED 109a2b: 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; 109a2c: a3 90 e5 11 00 mov %eax,0x11e590 109a31: e9 20 fd ff ff jmp 109756 =============================================================================== 00108590 : * Send characters to device-specific code */ void rtems_termios_puts ( const void *_buf, int len, struct rtems_termios_tty *tty) { 108590: 55 push %ebp 108591: 89 e5 mov %esp,%ebp 108593: 57 push %edi 108594: 56 push %esi 108595: 53 push %ebx 108596: 83 ec 1c sub $0x1c,%esp 108599: 8b 45 08 mov 0x8(%ebp),%eax 10859c: 8b 55 0c mov 0xc(%ebp),%edx 10859f: 89 55 e8 mov %edx,-0x18(%ebp) 1085a2: 8b 5d 10 mov 0x10(%ebp),%ebx const unsigned char *buf = _buf; 1085a5: 89 45 ec mov %eax,-0x14(%ebp) unsigned int newHead; rtems_interrupt_level level; rtems_status_code sc; if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { 1085a8: 8b 8b b4 00 00 00 mov 0xb4(%ebx),%ecx 1085ae: 85 c9 test %ecx,%ecx 1085b0: 0f 84 e6 00 00 00 je 10869c <== NEVER TAKEN (*tty->device.write)(tty->minor, (void *)buf, len); return; } newHead = tty->rawOutBuf.Head; 1085b6: 8b bb 80 00 00 00 mov 0x80(%ebx),%edi 1085bc: 89 7d f0 mov %edi,-0x10(%ebp) while (len) { 1085bf: 8b 45 e8 mov -0x18(%ebp),%eax 1085c2: 85 c0 test %eax,%eax 1085c4: 0f 84 ed 00 00 00 je 1086b7 <== NEVER TAKEN * len -= ncopy * * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size; 1085ca: 8b 75 f0 mov -0x10(%ebp),%esi 1085cd: 46 inc %esi 1085ce: 8b 8b 88 00 00 00 mov 0x88(%ebx),%ecx 1085d4: 89 f0 mov %esi,%eax 1085d6: 31 d2 xor %edx,%edx 1085d8: f7 f1 div %ecx 1085da: 89 55 e4 mov %edx,-0x1c(%ebp) 1085dd: 89 55 f0 mov %edx,-0x10(%ebp) rtems_interrupt_disable (level); 1085e0: 9c pushf 1085e1: fa cli 1085e2: 5e pop %esi while (newHead == tty->rawOutBuf.Tail) { 1085e3: 8b bb 84 00 00 00 mov 0x84(%ebx),%edi 1085e9: 39 d7 cmp %edx,%edi 1085eb: 75 33 jne 108620 1085ed: 8d 76 00 lea 0x0(%esi),%esi tty->rawOutBufState = rob_wait; 1085f0: c7 83 94 00 00 00 02 movl $0x2,0x94(%ebx) 1085f7: 00 00 00 rtems_interrupt_enable (level); 1085fa: 56 push %esi 1085fb: 9d popf sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, 1085fc: 50 push %eax 1085fd: 6a 00 push $0x0 1085ff: 6a 00 push $0x0 108601: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 108607: e8 e4 1d 00 00 call 10a3f0 RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) 10860c: 83 c4 10 add $0x10,%esp 10860f: 85 c0 test %eax,%eax 108611: 75 65 jne 108678 <== NEVER TAKEN rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); 108613: 9c pushf 108614: fa cli 108615: 5e pop %esi * 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) { 108616: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 10861c: 39 f8 cmp %edi,%eax 10861e: 74 d0 je 1085f0 <== NEVER TAKEN RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; 108620: 8b 8b 80 00 00 00 mov 0x80(%ebx),%ecx 108626: 8b 53 7c mov 0x7c(%ebx),%edx 108629: 8b 7d ec mov -0x14(%ebp),%edi 10862c: 8a 07 mov (%edi),%al 10862e: 88 04 0a mov %al,(%edx,%ecx,1) tty->rawOutBuf.Head = newHead; 108631: 8b 45 e4 mov -0x1c(%ebp),%eax 108634: 89 83 80 00 00 00 mov %eax,0x80(%ebx) if (tty->rawOutBufState == rob_idle) { 10863a: 8b 83 94 00 00 00 mov 0x94(%ebx),%eax 108640: 85 c0 test %eax,%eax 108642: 75 23 jne 108667 /* check, whether XOFF has been received */ if (!(tty->flow_ctrl & FL_ORCVXOF)) { 108644: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10864a: a8 10 test $0x10,%al 10864c: 74 33 je 108681 <== ALWAYS TAKEN (*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; 10864e: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108654: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 108657: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED } tty->rawOutBufState = rob_busy; 10865d: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) 108664: 00 00 00 } rtems_interrupt_enable (level); 108667: 56 push %esi 108668: 9d popf if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) { (*tty->device.write)(tty->minor, (void *)buf, len); return; } newHead = tty->rawOutBuf.Head; while (len) { 108669: ff 4d e8 decl -0x18(%ebp) 10866c: 74 49 je 1086b7 RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; 10866e: ff 45 ec incl -0x14(%ebp) 108671: e9 54 ff ff ff jmp 1085ca 108676: 66 90 xchg %ax,%ax 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); 108678: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 10867b: 50 push %eax <== NOT EXECUTED 10867c: e8 03 24 00 00 call 10aa84 <== 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, 108681: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 108687: 57 push %edi 108688: 6a 01 push $0x1 10868a: 03 43 7c add 0x7c(%ebx),%eax 10868d: 50 push %eax 10868e: ff 73 10 pushl 0x10(%ebx) 108691: ff 93 a4 00 00 00 call *0xa4(%ebx) 108697: 83 c4 10 add $0x10,%esp 10869a: eb c1 jmp 10865d 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); 10869c: 89 55 10 mov %edx,0x10(%ebp) <== NOT EXECUTED 10869f: 89 45 0c mov %eax,0xc(%ebp) <== NOT EXECUTED 1086a2: 8b 43 10 mov 0x10(%ebx),%eax <== NOT EXECUTED 1086a5: 89 45 08 mov %eax,0x8(%ebp) <== NOT EXECUTED 1086a8: 8b 8b a4 00 00 00 mov 0xa4(%ebx),%ecx <== NOT EXECUTED tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 1086ae: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 1086b1: 5b pop %ebx <== NOT EXECUTED 1086b2: 5e pop %esi <== NOT EXECUTED 1086b3: 5f pop %edi <== NOT EXECUTED 1086b4: 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); 1086b5: ff e1 jmp *%ecx <== NOT EXECUTED tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--; } } 1086b7: 8d 65 f4 lea -0xc(%ebp),%esp 1086ba: 5b pop %ebx 1086bb: 5e pop %esi 1086bc: 5f pop %edi 1086bd: c9 leave 1086be: c3 ret =============================================================================== 00108cc8 : return RTEMS_SUCCESSFUL; } rtems_status_code rtems_termios_read (void *arg) { 108cc8: 55 push %ebp <== NOT EXECUTED 108cc9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108ccb: 57 push %edi <== NOT EXECUTED 108ccc: 56 push %esi <== NOT EXECUTED 108ccd: 53 push %ebx <== NOT EXECUTED 108cce: 83 ec 30 sub $0x30,%esp <== NOT EXECUTED rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 108cd1: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 108cd4: 8b 02 mov (%edx),%eax <== NOT EXECUTED 108cd6: 8b 70 28 mov 0x28(%eax),%esi <== NOT EXECUTED uint32_t count = args->count; 108cd9: 8b 4a 0c mov 0xc(%edx),%ecx <== NOT EXECUTED 108cdc: 89 4d d0 mov %ecx,-0x30(%ebp) <== NOT EXECUTED char *buffer = args->buffer; 108cdf: 8b 42 08 mov 0x8(%edx),%eax <== NOT EXECUTED 108ce2: 89 45 d4 mov %eax,-0x2c(%ebp) <== NOT EXECUTED rtems_status_code sc; sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 108ce5: 6a 00 push $0x0 <== NOT EXECUTED 108ce7: 6a 00 push $0x0 <== NOT EXECUTED 108ce9: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 108cec: e8 ff 16 00 00 call 10a3f0 <== NOT EXECUTED 108cf1: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED if (sc != RTEMS_SUCCESSFUL) 108cf4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108cf7: 85 c0 test %eax,%eax <== NOT EXECUTED 108cf9: 75 35 jne 108d30 <== NOT EXECUTED return sc; if (rtems_termios_linesw[tty->t_line].l_read != NULL) { 108cfb: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax <== NOT EXECUTED 108d01: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 108d04: 8b 80 c8 e2 11 00 mov 0x11e2c8(%eax),%eax <== NOT EXECUTED 108d0a: 85 c0 test %eax,%eax <== NOT EXECUTED 108d0c: 74 2e je 108d3c <== NOT EXECUTED sc = rtems_termios_linesw[tty->t_line].l_read(tty,args); 108d0e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 108d11: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 108d14: 56 push %esi <== NOT EXECUTED 108d15: ff d0 call *%eax <== NOT EXECUTED 108d17: 89 45 d8 mov %eax,-0x28(%ebp) <== NOT EXECUTED tty->tty_rcvwakeup = 0; 108d1a: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) <== NOT EXECUTED 108d21: 00 00 00 rtems_semaphore_release (tty->isem); 108d24: 5b pop %ebx <== NOT EXECUTED 108d25: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 108d28: e8 bb 17 00 00 call 10a4e8 <== NOT EXECUTED 108d2d: 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; } 108d30: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 108d33: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108d36: 5b pop %ebx <== NOT EXECUTED 108d37: 5e pop %esi <== NOT EXECUTED 108d38: 5f pop %edi <== NOT EXECUTED 108d39: c9 leave <== NOT EXECUTED 108d3a: c3 ret <== NOT EXECUTED 108d3b: 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) { 108d3c: 8b 46 24 mov 0x24(%esi),%eax <== NOT EXECUTED 108d3f: 3b 46 20 cmp 0x20(%esi),%eax <== NOT EXECUTED 108d42: 74 60 je 108da4 <== NOT EXECUTED else sc = fillBufferQueue (tty); if (sc != RTEMS_SUCCESSFUL) tty->cindex = tty->ccount = 0; } while (count && (tty->cindex < tty->ccount)) { 108d44: 8b 45 d0 mov -0x30(%ebp),%eax <== NOT EXECUTED 108d47: 85 c0 test %eax,%eax <== NOT EXECUTED 108d49: 74 2a je 108d75 <== NOT EXECUTED 108d4b: 8b 56 24 mov 0x24(%esi),%edx <== NOT EXECUTED 108d4e: 3b 56 20 cmp 0x20(%esi),%edx <== NOT EXECUTED 108d51: 7c 0a jl 108d5d <== NOT EXECUTED 108d53: eb 20 jmp 108d75 <== NOT EXECUTED 108d55: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED 108d58: 39 56 20 cmp %edx,0x20(%esi) <== NOT EXECUTED 108d5b: 7e 18 jle 108d75 <== NOT EXECUTED *buffer++ = tty->cbuf[tty->cindex++]; 108d5d: 8b 46 1c mov 0x1c(%esi),%eax <== NOT EXECUTED 108d60: 8a 04 10 mov (%eax,%edx,1),%al <== NOT EXECUTED 108d63: 8b 4d d4 mov -0x2c(%ebp),%ecx <== NOT EXECUTED 108d66: 88 01 mov %al,(%ecx) <== NOT EXECUTED 108d68: 41 inc %ecx <== NOT EXECUTED 108d69: 89 4d d4 mov %ecx,-0x2c(%ebp) <== NOT EXECUTED 108d6c: 42 inc %edx <== NOT EXECUTED 108d6d: 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)) { 108d70: ff 4d d0 decl -0x30(%ebp) <== NOT EXECUTED 108d73: 75 e3 jne 108d58 <== NOT EXECUTED *buffer++ = tty->cbuf[tty->cindex++]; count--; } args->bytes_moved = args->count - count; 108d75: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 108d78: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 108d7b: 2b 45 d0 sub -0x30(%ebp),%eax <== NOT EXECUTED 108d7e: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED tty->tty_rcvwakeup = 0; 108d81: c7 86 e4 00 00 00 00 movl $0x0,0xe4(%esi) <== NOT EXECUTED 108d88: 00 00 00 rtems_semaphore_release (tty->isem); 108d8b: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108d8e: ff 76 14 pushl 0x14(%esi) <== NOT EXECUTED 108d91: e8 52 17 00 00 call 10a4e8 <== NOT EXECUTED 108d96: 83 c4 10 add $0x10,%esp <== NOT EXECUTED return sc; } 108d99: 8b 45 d8 mov -0x28(%ebp),%eax <== NOT EXECUTED 108d9c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108d9f: 5b pop %ebx <== NOT EXECUTED 108da0: 5e pop %esi <== NOT EXECUTED 108da1: 5f pop %edi <== NOT EXECUTED 108da2: c9 leave <== NOT EXECUTED 108da3: 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; 108da4: c7 46 20 00 00 00 00 movl $0x0,0x20(%esi) <== NOT EXECUTED 108dab: c7 46 24 00 00 00 00 movl $0x0,0x24(%esi) <== NOT EXECUTED tty->read_start_column = tty->column; 108db2: 8b 46 28 mov 0x28(%esi),%eax <== NOT EXECUTED 108db5: 89 46 2c mov %eax,0x2c(%esi) <== NOT EXECUTED if (tty->device.pollRead != NULL 108db8: 8b 86 a0 00 00 00 mov 0xa0(%esi),%eax <== NOT EXECUTED 108dbe: 89 c2 mov %eax,%edx <== NOT EXECUTED 108dc0: 85 c0 test %eax,%eax <== NOT EXECUTED 108dc2: 74 0e je 108dd2 <== NOT EXECUTED 108dc4: 8b 8e b4 00 00 00 mov 0xb4(%esi),%ecx <== NOT EXECUTED 108dca: 85 c9 test %ecx,%ecx <== NOT EXECUTED 108dcc: 0f 84 69 01 00 00 je 108f3b <== 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; 108dd2: 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, 108dd5: 8d 56 49 lea 0x49(%esi),%edx <== NOT EXECUTED 108dd8: 89 55 e0 mov %edx,-0x20(%ebp) <== NOT EXECUTED 108ddb: c7 45 dc 01 00 00 00 movl $0x1,-0x24(%ebp) <== NOT EXECUTED 108de2: 66 90 xchg %ax,%ax <== NOT EXECUTED while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 108de4: 8b 56 5c mov 0x5c(%esi),%edx <== NOT EXECUTED 108de7: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED 108dea: 39 c2 cmp %eax,%edx <== NOT EXECUTED 108dec: 75 2e jne 108e1c <== NOT EXECUTED 108dee: e9 f1 00 00 00 jmp 108ee4 <== NOT EXECUTED 108df3: 90 nop <== NOT EXECUTED } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { if (siproc (c, tty)) 108df4: 89 fa mov %edi,%edx <== NOT EXECUTED 108df6: 0f b6 c2 movzbl %dl,%eax <== NOT EXECUTED 108df9: 89 f2 mov %esi,%edx <== NOT EXECUTED 108dfb: e8 30 fd ff ff call 108b30 <== NOT EXECUTED 108e00: 85 c0 test %eax,%eax <== NOT EXECUTED 108e02: 74 07 je 108e0b <== NOT EXECUTED wait = 0; } else { siproc (c, tty); if (tty->ccount >= tty->termios.c_cc[VMIN]) 108e04: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp) <== NOT EXECUTED wait = 0; } timeout = tty->rawInBufSemaphoreTimeout; 108e0b: 8b 5e 70 mov 0x70(%esi),%ebx <== NOT EXECUTED while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 108e0e: 8b 56 5c mov 0x5c(%esi),%edx <== NOT EXECUTED 108e11: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED 108e14: 39 c2 cmp %eax,%edx <== NOT EXECUTED 108e16: 0f 84 c8 00 00 00 je 108ee4 <== NOT EXECUTED 108e1c: a1 84 c4 11 00 mov 0x11c484,%eax <== NOT EXECUTED 108e21: 48 dec %eax <== NOT EXECUTED 108e22: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED 108e25: 0f 8d b9 00 00 00 jge 108ee4 <== NOT EXECUTED (tty->ccount < (CBUFSIZE-1))) { unsigned char c; unsigned int newHead; newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size; 108e2b: 8b 46 5c mov 0x5c(%esi),%eax <== NOT EXECUTED 108e2e: 8b 56 64 mov 0x64(%esi),%edx <== NOT EXECUTED 108e31: 40 inc %eax <== NOT EXECUTED 108e32: 89 d1 mov %edx,%ecx <== NOT EXECUTED 108e34: 31 d2 xor %edx,%edx <== NOT EXECUTED 108e36: f7 f1 div %ecx <== NOT EXECUTED c = tty->rawInBuf.theBuf[newHead]; 108e38: 8b 46 58 mov 0x58(%esi),%eax <== NOT EXECUTED 108e3b: 0f b6 3c 10 movzbl (%eax,%edx,1),%edi <== NOT EXECUTED tty->rawInBuf.Head = newHead; 108e3f: 89 56 5c mov %edx,0x5c(%esi) <== NOT EXECUTED if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size) 108e42: 8b 5e 60 mov 0x60(%esi),%ebx <== NOT EXECUTED 108e45: 8b 46 64 mov 0x64(%esi),%eax <== NOT EXECUTED 108e48: 8b 4e 64 mov 0x64(%esi),%ecx <== NOT EXECUTED 108e4b: 01 d8 add %ebx,%eax <== NOT EXECUTED 108e4d: 29 d0 sub %edx,%eax <== NOT EXECUTED 108e4f: 31 d2 xor %edx,%edx <== NOT EXECUTED 108e51: f7 f1 div %ecx <== NOT EXECUTED 108e53: 3b 96 bc 00 00 00 cmp 0xbc(%esi),%edx <== NOT EXECUTED 108e59: 73 55 jae 108eb0 <== NOT EXECUTED % tty->rawInBuf.Size) < tty->lowwater) { tty->flow_ctrl &= ~FL_IREQXOF; 108e5b: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108e61: 83 e0 fe and $0xfffffffe,%eax <== NOT EXECUTED 108e64: 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)) 108e6a: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108e70: 25 02 02 00 00 and $0x202,%eax <== NOT EXECUTED 108e75: 3d 02 02 00 00 cmp $0x202,%eax <== NOT EXECUTED 108e7a: 0f 84 8c 00 00 00 je 108f0c <== 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) { 108e80: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108e86: f6 c4 01 test $0x1,%ah <== NOT EXECUTED 108e89: 74 25 je 108eb0 <== NOT EXECUTED tty->flow_ctrl &= ~FL_IRTSOFF; 108e8b: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108e91: 83 e0 fb and $0xfffffffb,%eax <== NOT EXECUTED 108e94: 89 86 b8 00 00 00 mov %eax,0xb8(%esi) <== NOT EXECUTED /* activate RTS line */ if (tty->device.startRemoteTx != NULL) { 108e9a: 8b 86 b0 00 00 00 mov 0xb0(%esi),%eax <== NOT EXECUTED 108ea0: 85 c0 test %eax,%eax <== NOT EXECUTED 108ea2: 74 0c je 108eb0 <== NOT EXECUTED tty->device.startRemoteTx(tty->minor); 108ea4: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108ea7: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 108eaa: ff d0 call *%eax <== NOT EXECUTED 108eac: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108eaf: 90 nop <== NOT EXECUTED } } } /* continue processing new character */ if (tty->termios.c_lflag & ICANON) { 108eb0: f6 46 3c 02 testb $0x2,0x3c(%esi) <== NOT EXECUTED 108eb4: 0f 85 3a ff ff ff jne 108df4 <== NOT EXECUTED if (siproc (c, tty)) wait = 0; } else { siproc (c, tty); 108eba: 89 f9 mov %edi,%ecx <== NOT EXECUTED 108ebc: 0f b6 c1 movzbl %cl,%eax <== NOT EXECUTED 108ebf: 89 f2 mov %esi,%edx <== NOT EXECUTED 108ec1: e8 6a fc ff ff call 108b30 <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 108ec6: 0f b6 46 47 movzbl 0x47(%esi),%eax <== NOT EXECUTED 108eca: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED 108ecd: 0f 8d 31 ff ff ff jge 108e04 <== NOT EXECUTED wait = 0; } timeout = tty->rawInBufSemaphoreTimeout; 108ed3: 8b 5e 70 mov 0x70(%esi),%ebx <== NOT EXECUTED while ( wait ) { /* * Process characters read from raw queue */ while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) && 108ed6: 8b 56 5c mov 0x5c(%esi),%edx <== NOT EXECUTED 108ed9: 8b 46 60 mov 0x60(%esi),%eax <== NOT EXECUTED 108edc: 39 c2 cmp %eax,%edx <== NOT EXECUTED 108ede: 0f 85 38 ff ff ff jne 108e1c <== NOT EXECUTED } /* * Wait for characters */ if ( wait ) { 108ee4: 8b 4d dc mov -0x24(%ebp),%ecx <== NOT EXECUTED 108ee7: 85 c9 test %ecx,%ecx <== NOT EXECUTED 108ee9: 0f 84 55 fe ff ff je 108d44 <== NOT EXECUTED sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore, 108eef: 52 push %edx <== NOT EXECUTED 108ef0: 53 push %ebx <== NOT EXECUTED 108ef1: ff 76 6c pushl 0x6c(%esi) <== NOT EXECUTED 108ef4: ff 76 68 pushl 0x68(%esi) <== NOT EXECUTED 108ef7: e8 f4 14 00 00 call 10a3f0 <== NOT EXECUTED tty->rawInBufSemaphoreOptions, timeout); if (sc != RTEMS_SUCCESSFUL) 108efc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108eff: 85 c0 test %eax,%eax <== NOT EXECUTED 108f01: 0f 84 dd fe ff ff je 108de4 <== NOT EXECUTED 108f07: e9 38 fe ff ff jmp 108d44 <== 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)) 108f0c: 8b 86 94 00 00 00 mov 0x94(%esi),%eax <== NOT EXECUTED 108f12: 85 c0 test %eax,%eax <== NOT EXECUTED 108f14: 74 0e je 108f24 <== NOT EXECUTED 108f16: 8b 86 b8 00 00 00 mov 0xb8(%esi),%eax <== NOT EXECUTED 108f1c: a8 20 test $0x20,%al <== NOT EXECUTED 108f1e: 0f 84 5c ff ff ff je 108e80 <== 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, 108f24: 53 push %ebx <== NOT EXECUTED 108f25: 6a 01 push $0x1 <== NOT EXECUTED 108f27: ff 75 e0 pushl -0x20(%ebp) <== NOT EXECUTED 108f2a: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 108f2d: ff 96 a4 00 00 00 call *0xa4(%esi) <== NOT EXECUTED 108f33: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f36: e9 75 ff ff ff jmp 108eb0 <== NOT EXECUTED static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 108f3b: f6 46 3c 02 testb $0x2,0x3c(%esi) <== NOT EXECUTED 108f3f: 0f 85 bf 00 00 00 jne 109004 <== NOT EXECUTED } } } else { rtems_interval then, now; if (!tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 108f45: 80 7e 47 00 cmpb $0x0,0x47(%esi) <== NOT EXECUTED 108f49: 75 1d jne 108f68 <== NOT EXECUTED 108f4b: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED 108f4f: 74 17 je 108f68 <== NOT EXECUTED rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &then); 108f51: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 108f54: 8d 45 f0 lea -0x10(%ebp),%eax <== NOT EXECUTED 108f57: 50 push %eax <== NOT EXECUTED 108f58: 6a 02 push $0x2 <== NOT EXECUTED 108f5a: e8 b1 0b 00 00 call 109b10 <== NOT EXECUTED 108f5f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f62: 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); 108f68: 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); 108f6b: 8d 5d ec lea -0x14(%ebp),%ebx <== NOT EXECUTED 108f6e: 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); 108f70: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108f73: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 108f76: ff d0 call *%eax <== NOT EXECUTED if (n < 0) { 108f78: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108f7b: 85 c0 test %eax,%eax <== NOT EXECUTED 108f7d: 79 3f jns 108fbe <== NOT EXECUTED if (tty->termios.c_cc[VMIN]) { 108f7f: 80 7e 47 00 cmpb $0x0,0x47(%esi) <== NOT EXECUTED 108f83: 0f 84 9b 00 00 00 je 109024 <== NOT EXECUTED if (tty->termios.c_cc[VTIME] && tty->ccount) { 108f89: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED 108f8d: 74 0d je 108f9c <== NOT EXECUTED 108f8f: 8b 46 20 mov 0x20(%esi),%eax <== NOT EXECUTED 108f92: 85 c0 test %eax,%eax <== NOT EXECUTED 108f94: 0f 85 94 00 00 00 jne 10902e <== NOT EXECUTED 108f9a: 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); 108f9c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108f9f: 6a 01 push $0x1 <== NOT EXECUTED 108fa1: e8 f6 18 00 00 call 10a89c <== NOT EXECUTED 108fa6: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108fa9: 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); 108faf: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108fb2: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 108fb5: ff d0 call *%eax <== NOT EXECUTED if (n < 0) { 108fb7: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108fba: 85 c0 test %eax,%eax <== NOT EXECUTED 108fbc: 78 c1 js 108f7f <== NOT EXECUTED } } rtems_task_wake_after (1); } else { siproc (n, tty); 108fbe: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 108fc1: 89 f2 mov %esi,%edx <== NOT EXECUTED 108fc3: e8 68 fb ff ff call 108b30 <== NOT EXECUTED if (tty->ccount >= tty->termios.c_cc[VMIN]) 108fc8: 8a 56 47 mov 0x47(%esi),%dl <== NOT EXECUTED 108fcb: 0f b6 c2 movzbl %dl,%eax <== NOT EXECUTED 108fce: 39 46 20 cmp %eax,0x20(%esi) <== NOT EXECUTED 108fd1: 0f 8d 6d fd ff ff jge 108d44 <== NOT EXECUTED break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME]) 108fd7: 84 d2 test %dl,%dl <== NOT EXECUTED 108fd9: 74 06 je 108fe1 <== NOT EXECUTED 108fdb: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED 108fdf: 75 6f jne 109050 <== NOT EXECUTED 108fe1: 8b 86 a0 00 00 00 mov 0xa0(%esi),%eax <== NOT EXECUTED 108fe7: eb 87 jmp 108f70 <== NOT EXECUTED 108fe9: 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)) 108fec: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED 108fef: 89 f2 mov %esi,%edx <== NOT EXECUTED 108ff1: e8 3a fb ff ff call 108b30 <== NOT EXECUTED 108ff6: 85 c0 test %eax,%eax <== NOT EXECUTED 108ff8: 0f 85 46 fd ff ff jne 108d44 <== NOT EXECUTED static rtems_status_code fillBufferPoll (struct rtems_termios_tty *tty) { int n; if (tty->termios.c_lflag & ICANON) { 108ffe: 8b 96 a0 00 00 00 mov 0xa0(%esi),%edx <== NOT EXECUTED for (;;) { n = (*tty->device.pollRead)(tty->minor); 109004: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109007: ff 76 10 pushl 0x10(%esi) <== NOT EXECUTED 10900a: ff d2 call *%edx <== NOT EXECUTED if (n < 0) { 10900c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10900f: 85 c0 test %eax,%eax <== NOT EXECUTED 109011: 79 d9 jns 108fec <== NOT EXECUTED rtems_task_wake_after (1); 109013: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109016: 6a 01 push $0x1 <== NOT EXECUTED 109018: e8 7f 18 00 00 call 10a89c <== NOT EXECUTED 10901d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109020: eb dc jmp 108ffe <== NOT EXECUTED 109022: 66 90 xchg %ax,%ax <== NOT EXECUTED break; } } } else { if (!tty->termios.c_cc[VTIME]) 109024: 80 7e 46 00 cmpb $0x0,0x46(%esi) <== NOT EXECUTED 109028: 0f 84 16 fd ff ff je 108d44 <== NOT EXECUTED break; rtems_clock_get (RTEMS_CLOCK_GET_TICKS_SINCE_BOOT, &now); 10902e: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109031: 53 push %ebx <== NOT EXECUTED 109032: 6a 02 push $0x2 <== NOT EXECUTED 109034: e8 d7 0a 00 00 call 109b10 <== NOT EXECUTED if ((now - then) > tty->vtimeTicks) { 109039: 8b 45 ec mov -0x14(%ebp),%eax <== NOT EXECUTED 10903c: 2b 45 f0 sub -0x10(%ebp),%eax <== NOT EXECUTED 10903f: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109042: 3b 46 54 cmp 0x54(%esi),%eax <== NOT EXECUTED 109045: 0f 86 51 ff ff ff jbe 108f9c <== NOT EXECUTED 10904b: e9 f4 fc ff ff jmp 108d44 <== 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); 109050: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 109053: 57 push %edi <== NOT EXECUTED 109054: 6a 02 push $0x2 <== NOT EXECUTED 109056: e8 b5 0a 00 00 call 109b10 <== NOT EXECUTED 10905b: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10905e: eb 81 jmp 108fe1 <== NOT EXECUTED =============================================================================== 00108014 : * 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) { 108014: 55 push %ebp 108015: 89 e5 mov %esp,%ebp 108017: 57 push %edi 108018: 56 push %esi 108019: 53 push %ebx 10801a: 83 ec 0c sub $0xc,%esp 10801d: 8b 5d 08 mov 0x8(%ebp),%ebx int nToSend; rtems_interrupt_level level; int len; /* check for XOF/XON to send */ if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF)) 108020: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 108026: 25 03 04 00 00 and $0x403,%eax 10802b: 3d 01 04 00 00 cmp $0x401,%eax 108030: 0f 84 02 01 00 00 je 108138 <== NEVER TAKEN tty->flow_ctrl |= FL_ISNTXOF; rtems_interrupt_enable(level); nToSend = 1; } else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) 108036: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 10803c: 83 e0 03 and $0x3,%eax 10803f: 83 f8 02 cmp $0x2,%eax 108042: 0f 84 84 01 00 00 je 1081cc <== NEVER TAKEN rtems_interrupt_enable(level); nToSend = 1; } else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { 108048: 8b 93 80 00 00 00 mov 0x80(%ebx),%edx 10804e: 8b 83 84 00 00 00 mov 0x84(%ebx),%eax 108054: 39 c2 cmp %eax,%edx 108056: 0f 84 b4 00 00 00 je 108110 <== NEVER TAKEN rtems_semaphore_release (tty->rawOutBuf.Semaphore); } return 0; } rtems_interrupt_disable(level); 10805c: 9c pushf 10805d: fa cli 10805e: 58 pop %eax len = tty->t_dqlen; 10805f: 8b 8b 90 00 00 00 mov 0x90(%ebx),%ecx tty->t_dqlen = 0; 108065: c7 83 90 00 00 00 00 movl $0x0,0x90(%ebx) 10806c: 00 00 00 rtems_interrupt_enable(level); 10806f: 50 push %eax 108070: 9d popf newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size; 108071: 8b 93 84 00 00 00 mov 0x84(%ebx),%edx 108077: 8b b3 88 00 00 00 mov 0x88(%ebx),%esi 10807d: 01 d1 add %edx,%ecx 10807f: 89 c8 mov %ecx,%eax 108081: 31 d2 xor %edx,%edx 108083: f7 f6 div %esi 108085: 89 d7 mov %edx,%edi tty->rawOutBuf.Tail = newTail; 108087: 89 93 84 00 00 00 mov %edx,0x84(%ebx) if (tty->rawOutBufState == rob_wait) { 10808d: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) 108094: 0f 84 6e 01 00 00 je 108208 /* * wake up any pending writer task */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); } if (newTail == tty->rawOutBuf.Head) { 10809a: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 1080a0: 39 f8 cmp %edi,%eax 1080a2: 0f 84 cc 00 00 00 je 108174 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)) 1080a8: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1080ae: 25 10 02 00 00 and $0x210,%eax 1080b3: 3d 10 02 00 00 cmp $0x210,%eax 1080b8: 0f 84 e6 00 00 00 je 1081a4 <== NEVER TAKEN } else { /* * Buffer not empty, start tranmitter */ if (newTail > tty->rawOutBuf.Head) 1080be: 8b 83 80 00 00 00 mov 0x80(%ebx),%eax 1080c4: 39 c7 cmp %eax,%edi 1080c6: 77 64 ja 10812c nToSend = tty->rawOutBuf.Size - newTail; else nToSend = tty->rawOutBuf.Head - newTail; 1080c8: 8b b3 80 00 00 00 mov 0x80(%ebx),%esi 1080ce: 29 fe sub %edi,%esi /* 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)) { 1080d0: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax 1080d6: f6 c4 06 test $0x6,%ah 1080d9: 74 05 je 1080e0 <== ALWAYS TAKEN 1080db: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED nToSend = 1; } tty->rawOutBufState = rob_busy; /*apm*/ 1080e0: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) 1080e7: 00 00 00 (*tty->device.write)(tty->minor, 1080ea: 50 push %eax 1080eb: 56 push %esi 1080ec: 8b 43 7c mov 0x7c(%ebx),%eax 1080ef: 01 f8 add %edi,%eax 1080f1: 50 push %eax 1080f2: ff 73 10 pushl 0x10(%ebx) 1080f5: ff 93 a4 00 00 00 call *0xa4(%ebx) 1080fb: 83 c4 10 add $0x10,%esp &tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ 1080fe: 89 bb 84 00 00 00 mov %edi,0x84(%ebx) } return nToSend; } 108104: 89 f0 mov %esi,%eax 108106: 8d 65 f4 lea -0xc(%ebp),%esp 108109: 5b pop %ebx 10810a: 5e pop %esi 10810b: 5f pop %edi 10810c: c9 leave 10810d: c3 ret 10810e: 66 90 xchg %ax,%ax else { if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) { /* * buffer was empty */ if (tty->rawOutBufState == rob_wait) { 108110: 83 bb 94 00 00 00 02 cmpl $0x2,0x94(%ebx) <== NOT EXECUTED 108117: 0f 84 03 01 00 00 je 108220 <== NOT EXECUTED 10811d: 31 f6 xor %esi,%esi <== NOT EXECUTED nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 10811f: 89 f0 mov %esi,%eax <== NOT EXECUTED 108121: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108124: 5b pop %ebx <== NOT EXECUTED 108125: 5e pop %esi <== NOT EXECUTED 108126: 5f pop %edi <== NOT EXECUTED 108127: c9 leave <== NOT EXECUTED 108128: c3 ret <== NOT EXECUTED 108129: 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; 10812c: 8b b3 88 00 00 00 mov 0x88(%ebx),%esi 108132: 29 fe sub %edi,%esi 108134: eb 9a jmp 1080d0 108136: 66 90 xchg %ax,%ax /* 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, 108138: 51 push %ecx <== NOT EXECUTED 108139: 6a 01 push $0x1 <== NOT EXECUTED 10813b: 8d 43 4a lea 0x4a(%ebx),%eax <== NOT EXECUTED 10813e: 50 push %eax <== NOT EXECUTED 10813f: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 108142: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTOP]), 1); rtems_interrupt_disable(level); 108148: 9c pushf <== NOT EXECUTED 108149: fa cli <== NOT EXECUTED 10814a: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 10814b: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl |= FL_ISNTXOF; 108151: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 108157: 83 c8 02 or $0x2,%eax <== NOT EXECUTED 10815a: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 108160: 52 push %edx <== NOT EXECUTED 108161: 9d popf <== NOT EXECUTED 108162: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 108167: 83 c4 10 add $0x10,%esp <== NOT EXECUTED nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 10816a: 89 f0 mov %esi,%eax <== NOT EXECUTED 10816c: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 10816f: 5b pop %ebx <== NOT EXECUTED 108170: 5e pop %esi <== NOT EXECUTED 108171: 5f pop %edi <== NOT EXECUTED 108172: c9 leave <== NOT EXECUTED 108173: c3 ret <== NOT EXECUTED } if (newTail == tty->rawOutBuf.Head) { /* * Buffer has become empty */ tty->rawOutBufState = rob_idle; 108174: c7 83 94 00 00 00 00 movl $0x0,0x94(%ebx) 10817b: 00 00 00 nToSend = 0; /* * check to see if snd wakeup callback was set */ if ( tty->tty_snd.sw_pfn != NULL) { 10817e: 8b 93 d4 00 00 00 mov 0xd4(%ebx),%edx 108184: 85 d2 test %edx,%edx 108186: 74 3a je 1081c2 <== ALWAYS TAKEN (*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg); 108188: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 10818b: ff b3 d8 00 00 00 pushl 0xd8(%ebx) <== NOT EXECUTED 108191: 8d 43 30 lea 0x30(%ebx),%eax <== NOT EXECUTED 108194: 50 push %eax <== NOT EXECUTED 108195: ff d2 call *%edx <== NOT EXECUTED 108197: 31 f6 xor %esi,%esi <== NOT EXECUTED 108199: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 10819c: e9 5d ff ff ff jmp 1080fe <== NOT EXECUTED 1081a1: 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); 1081a4: 9c pushf <== NOT EXECUTED 1081a5: fa cli <== NOT EXECUTED 1081a6: 5a pop %edx <== NOT EXECUTED tty->flow_ctrl |= FL_OSTOP; 1081a7: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1081ad: 83 c8 20 or $0x20,%eax <== NOT EXECUTED 1081b0: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED tty->rawOutBufState = rob_busy; /*apm*/ 1081b6: c7 83 94 00 00 00 01 movl $0x1,0x94(%ebx) <== NOT EXECUTED 1081bd: 00 00 00 rtems_interrupt_enable(level); 1081c0: 52 push %edx <== NOT EXECUTED 1081c1: 9d popf <== NOT EXECUTED 1081c2: 31 f6 xor %esi,%esi 1081c4: e9 35 ff ff ff jmp 1080fe 1081c9: 8d 76 00 lea 0x0(%esi),%esi * 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, 1081cc: 52 push %edx <== NOT EXECUTED 1081cd: 6a 01 push $0x1 <== NOT EXECUTED 1081cf: 8d 43 49 lea 0x49(%ebx),%eax <== NOT EXECUTED 1081d2: 50 push %eax <== NOT EXECUTED 1081d3: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 1081d6: ff 93 a4 00 00 00 call *0xa4(%ebx) <== NOT EXECUTED (void *)&(tty->termios.c_cc[VSTART]), 1); rtems_interrupt_disable(level); 1081dc: 9c pushf <== NOT EXECUTED 1081dd: fa cli <== NOT EXECUTED 1081de: 5a pop %edx <== NOT EXECUTED tty->t_dqlen--; 1081df: ff 8b 90 00 00 00 decl 0x90(%ebx) <== NOT EXECUTED tty->flow_ctrl &= ~FL_ISNTXOF; 1081e5: 8b 83 b8 00 00 00 mov 0xb8(%ebx),%eax <== NOT EXECUTED 1081eb: 83 e0 fd and $0xfffffffd,%eax <== NOT EXECUTED 1081ee: 89 83 b8 00 00 00 mov %eax,0xb8(%ebx) <== NOT EXECUTED rtems_interrupt_enable(level); 1081f4: 52 push %edx <== NOT EXECUTED 1081f5: 9d popf <== NOT EXECUTED 1081f6: be 01 00 00 00 mov $0x1,%esi <== NOT EXECUTED 1081fb: 83 c4 10 add $0x10,%esp <== NOT EXECUTED nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; } 1081fe: 89 f0 mov %esi,%eax <== NOT EXECUTED 108200: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108203: 5b pop %ebx <== NOT EXECUTED 108204: 5e pop %esi <== NOT EXECUTED 108205: 5f pop %edi <== NOT EXECUTED 108206: c9 leave <== NOT EXECUTED 108207: 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); 108208: 83 ec 0c sub $0xc,%esp 10820b: ff b3 8c 00 00 00 pushl 0x8c(%ebx) 108211: e8 d2 22 00 00 call 10a4e8 108216: 83 c4 10 add $0x10,%esp 108219: e9 7c fe ff ff jmp 10809a 10821e: 66 90 xchg %ax,%ax */ if (tty->rawOutBufState == rob_wait) { /* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore); 108220: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 108223: ff b3 8c 00 00 00 pushl 0x8c(%ebx) <== NOT EXECUTED 108229: e8 ba 22 00 00 call 10a4e8 <== NOT EXECUTED 10822e: 31 f6 xor %esi,%esi <== NOT EXECUTED 108230: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108233: e9 e7 fe ff ff jmp 10811f <== NOT EXECUTED =============================================================================== 00109aa4 : /* * this task actually processes any receive events */ static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument) { 109aa4: 55 push %ebp <== NOT EXECUTED 109aa5: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109aa7: 57 push %edi <== NOT EXECUTED 109aa8: 56 push %esi <== NOT EXECUTED 109aa9: 53 push %ebx <== NOT EXECUTED 109aaa: 83 ec 1c sub $0x1c,%esp <== NOT EXECUTED 109aad: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 109ab0: 8d 75 ec lea -0x14(%ebp),%esi <== NOT EXECUTED 109ab3: 8d 7d f3 lea -0xd(%ebp),%edi <== NOT EXECUTED 109ab6: 66 90 xchg %ax,%ax <== NOT EXECUTED char c_buf; while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_RX_PROC_EVENT | 109ab8: 56 push %esi <== NOT EXECUTED 109ab9: 6a 00 push $0x0 <== NOT EXECUTED 109abb: 6a 02 push $0x2 <== NOT EXECUTED 109abd: 6a 03 push $0x3 <== NOT EXECUTED 109abf: e8 74 02 00 00 call 109d38 <== NOT EXECUTED TERMIOS_RX_TERMINATE_EVENT), RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &the_event); if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) { 109ac4: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109ac7: f6 45 ec 01 testb $0x1,-0x14(%ebp) <== NOT EXECUTED 109acb: 75 27 jne 109af4 <== NOT EXECUTED } else { /* * do something */ c = tty->device.pollRead(tty->minor); 109acd: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109ad0: ff 73 10 pushl 0x10(%ebx) <== NOT EXECUTED 109ad3: ff 93 a0 00 00 00 call *0xa0(%ebx) <== NOT EXECUTED if (c != EOF) { 109ad9: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109adc: 83 f8 ff cmp $0xffffffff,%eax <== NOT EXECUTED 109adf: 74 d7 je 109ab8 <== NOT EXECUTED /* * pollRead did call enqueue on its own */ c_buf = c; 109ae1: 88 45 f3 mov %al,-0xd(%ebp) <== NOT EXECUTED rtems_termios_enqueue_raw_characters ( 109ae4: 50 push %eax <== NOT EXECUTED 109ae5: 6a 01 push $0x1 <== NOT EXECUTED 109ae7: 57 push %edi <== NOT EXECUTED 109ae8: 53 push %ebx <== NOT EXECUTED 109ae9: e8 b2 e7 ff ff call 1082a0 <== NOT EXECUTED 109aee: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109af1: eb c5 jmp 109ab8 <== NOT EXECUTED 109af3: 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; 109af4: c7 83 c4 00 00 00 00 movl $0x0,0xc4(%ebx) <== NOT EXECUTED 109afb: 00 00 00 rtems_task_delete(RTEMS_SELF); 109afe: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109b01: 6a 00 push $0x0 <== NOT EXECUTED 109b03: e8 d4 0b 00 00 call 10a6dc <== NOT EXECUTED 109b08: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109b0b: eb ab jmp 109ab8 <== NOT EXECUTED =============================================================================== 00107ff8 : * 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) { 107ff8: 55 push %ebp <== NOT EXECUTED 107ff9: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107ffb: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED /* * send event to rx daemon task */ rtems_event_send(tty->rxTaskId,TERMIOS_RX_PROC_EVENT); 107ffe: 6a 02 push $0x2 <== NOT EXECUTED 108000: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108003: ff b0 c4 00 00 00 pushl 0xc4(%eax) <== NOT EXECUTED 108009: e8 be 1e 00 00 call 109ecc <== NOT EXECUTED 10800e: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } 108011: c9 leave <== NOT EXECUTED 108012: c3 ret <== NOT EXECUTED =============================================================================== 00109a38 : /* * this task actually processes any transmit events */ static rtems_task rtems_termios_txdaemon(rtems_task_argument argument) { 109a38: 55 push %ebp <== NOT EXECUTED 109a39: 89 e5 mov %esp,%ebp <== NOT EXECUTED 109a3b: 56 push %esi <== NOT EXECUTED 109a3c: 53 push %ebx <== NOT EXECUTED 109a3d: 83 ec 10 sub $0x10,%esp <== NOT EXECUTED 109a40: 8b 5d 08 mov 0x8(%ebp),%ebx <== NOT EXECUTED 109a43: 8d 75 f4 lea -0xc(%ebp),%esi <== NOT EXECUTED 109a46: 66 90 xchg %ax,%ax <== NOT EXECUTED while (1) { /* * wait for rtems event */ rtems_event_receive((TERMIOS_TX_START_EVENT | 109a48: 56 push %esi <== NOT EXECUTED 109a49: 6a 00 push $0x0 <== NOT EXECUTED 109a4b: 6a 02 push $0x2 <== NOT EXECUTED 109a4d: 6a 03 push $0x3 <== NOT EXECUTED 109a4f: e8 e4 02 00 00 call 109d38 <== NOT EXECUTED TERMIOS_TX_TERMINATE_EVENT), RTEMS_EVENT_ANY | RTEMS_WAIT, RTEMS_NO_TIMEOUT, &the_event); if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) { 109a54: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a57: f6 45 f4 01 testb $0x1,-0xc(%ebp) <== NOT EXECUTED 109a5b: 75 2b jne 109a88 <== NOT EXECUTED } else { /* * call any line discipline start function */ if (rtems_termios_linesw[tty->t_line].l_start != NULL) { 109a5d: 8b 83 cc 00 00 00 mov 0xcc(%ebx),%eax <== NOT EXECUTED 109a63: c1 e0 05 shl $0x5,%eax <== NOT EXECUTED 109a66: 8b 80 d4 e2 11 00 mov 0x11e2d4(%eax),%eax <== NOT EXECUTED 109a6c: 85 c0 test %eax,%eax <== NOT EXECUTED 109a6e: 74 09 je 109a79 <== NOT EXECUTED rtems_termios_linesw[tty->t_line].l_start(tty); 109a70: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109a73: 53 push %ebx <== NOT EXECUTED 109a74: ff d0 call *%eax <== NOT EXECUTED 109a76: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } /* * try to push further characters to device */ rtems_termios_refill_transmitter(tty); 109a79: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109a7c: 53 push %ebx <== NOT EXECUTED 109a7d: e8 92 e5 ff ff call 108014 <== NOT EXECUTED 109a82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a85: eb c1 jmp 109a48 <== NOT EXECUTED 109a87: 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; 109a88: c7 83 c8 00 00 00 00 movl $0x0,0xc8(%ebx) <== NOT EXECUTED 109a8f: 00 00 00 rtems_task_delete(RTEMS_SELF); 109a92: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 109a95: 6a 00 push $0x0 <== NOT EXECUTED 109a97: e8 40 0c 00 00 call 10a6dc <== NOT EXECUTED 109a9c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 109a9f: eb a7 jmp 109a48 <== NOT EXECUTED =============================================================================== 00108b80 : rtems_termios_puts (&c, 1, tty); } rtems_status_code rtems_termios_write (void *arg) { 108b80: 55 push %ebp 108b81: 89 e5 mov %esp,%ebp 108b83: 57 push %edi 108b84: 56 push %esi 108b85: 53 push %ebx 108b86: 83 ec 10 sub $0x10,%esp rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1; 108b89: 8b 55 08 mov 0x8(%ebp),%edx 108b8c: 8b 02 mov (%edx),%eax 108b8e: 8b 70 28 mov 0x28(%eax),%esi rtems_status_code sc; sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT); 108b91: 6a 00 push $0x0 108b93: 6a 00 push $0x0 108b95: ff 76 18 pushl 0x18(%esi) 108b98: e8 53 18 00 00 call 10a3f0 108b9d: 89 c7 mov %eax,%edi if (sc != RTEMS_SUCCESSFUL) 108b9f: 83 c4 10 add $0x10,%esp 108ba2: 85 c0 test %eax,%eax 108ba4: 75 2a jne 108bd0 <== NEVER TAKEN return sc; if (rtems_termios_linesw[tty->t_line].l_write != NULL) { 108ba6: 8b 86 cc 00 00 00 mov 0xcc(%esi),%eax 108bac: c1 e0 05 shl $0x5,%eax 108baf: 8b 80 cc e2 11 00 mov 0x11e2cc(%eax),%eax 108bb5: 85 c0 test %eax,%eax 108bb7: 74 23 je 108bdc <== ALWAYS TAKEN sc = rtems_termios_linesw[tty->t_line].l_write(tty,args); 108bb9: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 108bbc: ff 75 08 pushl 0x8(%ebp) <== NOT EXECUTED 108bbf: 56 push %esi <== NOT EXECUTED 108bc0: ff d0 call *%eax <== NOT EXECUTED 108bc2: 89 c7 mov %eax,%edi <== NOT EXECUTED rtems_semaphore_release (tty->osem); 108bc4: 58 pop %eax <== NOT EXECUTED 108bc5: ff 76 18 pushl 0x18(%esi) <== NOT EXECUTED 108bc8: e8 1b 19 00 00 call 10a4e8 <== NOT EXECUTED 108bcd: 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; } 108bd0: 89 f8 mov %edi,%eax <== NOT EXECUTED 108bd2: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 108bd5: 5b pop %ebx <== NOT EXECUTED 108bd6: 5e pop %esi <== NOT EXECUTED 108bd7: 5f pop %edi <== NOT EXECUTED 108bd8: c9 leave <== NOT EXECUTED 108bd9: c3 ret <== NOT EXECUTED 108bda: 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) { 108bdc: f6 46 34 01 testb $0x1,0x34(%esi) 108be0: 74 52 je 108c34 <== NEVER TAKEN uint32_t count = args->count; 108be2: 8b 45 08 mov 0x8(%ebp),%eax 108be5: 8b 40 0c mov 0xc(%eax),%eax 108be8: 89 45 ec mov %eax,-0x14(%ebp) char *buffer = args->buffer; 108beb: 8b 55 08 mov 0x8(%ebp),%edx 108bee: 8b 52 08 mov 0x8(%edx),%edx 108bf1: 89 55 f0 mov %edx,-0x10(%ebp) while (count--) 108bf4: 85 c0 test %eax,%eax 108bf6: 74 1e je 108c16 <== NEVER TAKEN 108bf8: 31 db xor %ebx,%ebx 108bfa: 66 90 xchg %ax,%ax oproc (*buffer++, tty); 108bfc: 8b 55 f0 mov -0x10(%ebp),%edx 108bff: 0f b6 04 1a movzbl (%edx,%ebx,1),%eax 108c03: 89 f2 mov %esi,%edx 108c05: e8 b6 fa ff ff call 1086c0 108c0a: 43 inc %ebx return sc; } if (tty->termios.c_oflag & OPOST) { uint32_t count = args->count; char *buffer = args->buffer; while (count--) 108c0b: 39 5d ec cmp %ebx,-0x14(%ebp) 108c0e: 75 ec jne 108bfc 108c10: 8b 55 08 mov 0x8(%ebp),%edx 108c13: 8b 42 0c mov 0xc(%edx),%eax oproc (*buffer++, tty); args->bytes_moved = args->count; 108c16: 8b 55 08 mov 0x8(%ebp),%edx 108c19: 89 42 14 mov %eax,0x14(%edx) } else { rtems_termios_puts (args->buffer, args->count, tty); args->bytes_moved = args->count; } rtems_semaphore_release (tty->osem); 108c1c: 83 ec 0c sub $0xc,%esp 108c1f: ff 76 18 pushl 0x18(%esi) 108c22: e8 c1 18 00 00 call 10a4e8 108c27: 83 c4 10 add $0x10,%esp return sc; } 108c2a: 89 f8 mov %edi,%eax 108c2c: 8d 65 f4 lea -0xc(%ebp),%esp 108c2f: 5b pop %ebx 108c30: 5e pop %esi 108c31: 5f pop %edi 108c32: c9 leave 108c33: c3 ret while (count--) oproc (*buffer++, tty); args->bytes_moved = args->count; } else { rtems_termios_puts (args->buffer, args->count, tty); 108c34: 50 push %eax <== NOT EXECUTED 108c35: 56 push %esi <== NOT EXECUTED 108c36: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED 108c39: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 108c3c: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 108c3f: e8 4c f9 ff ff call 108590 <== NOT EXECUTED args->bytes_moved = args->count; 108c44: 8b 55 08 mov 0x8(%ebp),%edx <== NOT EXECUTED 108c47: 8b 42 0c mov 0xc(%edx),%eax <== NOT EXECUTED 108c4a: 89 42 14 mov %eax,0x14(%edx) <== NOT EXECUTED 108c4d: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 108c50: eb ca jmp 108c1c <== NOT EXECUTED =============================================================================== 00114448 : */ rtems_status_code rtems_timer_cancel( Objects_Id id ) { 114448: 55 push %ebp 114449: 89 e5 mov %esp,%ebp 11444b: 83 ec 1c sub $0x1c,%esp /** * 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 11444e: 8d 45 fc lea -0x4(%ebp),%eax 114451: 50 push %eax 114452: ff 75 08 pushl 0x8(%ebp) 114455: 68 a0 5d 13 00 push $0x135da0 11445a: e8 81 27 00 00 call 116be0 <_Objects_Get> Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 11445f: 83 c4 10 add $0x10,%esp 114462: 8b 55 fc mov -0x4(%ebp),%edx 114465: 85 d2 test %edx,%edx 114467: 74 07 je 114470 114469: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11446e: c9 leave 11446f: c3 ret the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: if ( !_Timer_Is_dormant_class( the_timer->the_class ) ) 114470: 83 78 38 04 cmpl $0x4,0x38(%eax) 114474: 74 0f je 114485 <== NEVER TAKEN (void) _Watchdog_Remove( &the_timer->Ticker ); 114476: 83 ec 0c sub $0xc,%esp 114479: 83 c0 10 add $0x10,%eax 11447c: 50 push %eax 11447d: e8 9a 43 00 00 call 11881c <_Watchdog_Remove> 114482: 83 c4 10 add $0x10,%esp _Thread_Enable_dispatch(); 114485: e8 9a 2f 00 00 call 117424 <_Thread_Enable_dispatch> 11448a: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11448c: c9 leave 11448d: c3 ret =============================================================================== 00114490 : rtems_status_code rtems_timer_create( rtems_name name, Objects_Id *id ) { 114490: 55 push %ebp 114491: 89 e5 mov %esp,%ebp 114493: 57 push %edi 114494: 56 push %esi 114495: 53 push %ebx 114496: 83 ec 0c sub $0xc,%esp 114499: 8b 75 08 mov 0x8(%ebp),%esi 11449c: 8b 7d 0c mov 0xc(%ebp),%edi Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 11449f: 85 f6 test %esi,%esi 1144a1: 74 71 je 114514 return RTEMS_INVALID_NAME; if ( !id ) 1144a3: 85 ff test %edi,%edi 1144a5: 0f 84 8d 00 00 00 je 114538 <== NEVER TAKEN /** * This routine walks the heap and tots up the free and allocated * sizes. * * @param[in] the_heap pointer to heap header 1144ab: a1 38 5a 13 00 mov 0x135a38,%eax 1144b0: 40 inc %eax 1144b1: a3 38 5a 13 00 mov %eax,0x135a38 #ifdef __cplusplus extern "C" { #endif /** 1144b6: 83 ec 0c sub $0xc,%esp 1144b9: 68 a0 5d 13 00 push $0x135da0 1144be: e8 e9 21 00 00 call 1166ac <_Objects_Allocate> 1144c3: 89 c3 mov %eax,%ebx _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { 1144c5: 83 c4 10 add $0x10,%esp 1144c8: 85 c0 test %eax,%eax 1144ca: 74 58 je 114524 _Thread_Enable_dispatch(); return RTEMS_TOO_MANY; } the_timer->the_class = TIMER_DORMANT; 1144cc: c7 40 38 04 00 00 00 movl $0x4,0x38(%eax) * 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. * 1144d3: c7 40 18 00 00 00 00 movl $0x0,0x18(%eax) * @param[in] the_heap is the heap to operate upon 1144da: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax) * @param[in] starting_address is the starting address of the memory for 1144e1: c7 40 30 00 00 00 00 movl $0x0,0x30(%eax) * the heap 1144e8: c7 40 34 00 00 00 00 movl $0x0,0x34(%eax) 1144ef: 8b 48 08 mov 0x8(%eax),%ecx 1144f2: 0f b7 d1 movzwl %cx,%edx 1144f5: a1 bc 5d 13 00 mov 0x135dbc,%eax 1144fa: 89 1c 90 mov %ebx,(%eax,%edx,4) 1144fd: 89 73 0c mov %esi,0xc(%ebx) &_Timer_Information, &the_timer->Object, (Objects_Name) name ); *id = the_timer->Object.id; 114500: 89 0f mov %ecx,(%edi) _Thread_Enable_dispatch(); 114502: e8 1d 2f 00 00 call 117424 <_Thread_Enable_dispatch> 114507: 31 c0 xor %eax,%eax return RTEMS_SUCCESSFUL; } 114509: 8d 65 f4 lea -0xc(%ebp),%esp 11450c: 5b pop %ebx 11450d: 5e pop %esi 11450e: 5f pop %edi 11450f: c9 leave 114510: c3 ret 114511: 8d 76 00 lea 0x0(%esi),%esi Objects_Id *id ) { Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) 114514: b8 03 00 00 00 mov $0x3,%eax ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 114519: 8d 65 f4 lea -0xc(%ebp),%esp 11451c: 5b pop %ebx 11451d: 5e pop %esi 11451e: 5f pop %edi 11451f: c9 leave 114520: c3 ret 114521: 8d 76 00 lea 0x0(%esi),%esi _Thread_Disable_dispatch(); /* to prevent deletion */ the_timer = _Timer_Allocate(); if ( !the_timer ) { _Thread_Enable_dispatch(); 114524: e8 fb 2e 00 00 call 117424 <_Thread_Enable_dispatch> 114529: b8 05 00 00 00 mov $0x5,%eax ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 11452e: 8d 65 f4 lea -0xc(%ebp),%esp 114531: 5b pop %ebx 114532: 5e pop %esi 114533: 5f pop %edi 114534: c9 leave 114535: c3 ret 114536: 66 90 xchg %ax,%ax Timer_Control *the_timer; if ( !rtems_is_name_valid( name ) ) return RTEMS_INVALID_NAME; if ( !id ) 114538: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED ); *id = the_timer->Object.id; _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; } 11453d: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 114540: 5b pop %ebx <== NOT EXECUTED 114541: 5e pop %esi <== NOT EXECUTED 114542: 5f pop %edi <== NOT EXECUTED 114543: c9 leave <== NOT EXECUTED 114544: c3 ret <== NOT EXECUTED =============================================================================== 00114548 : */ rtems_status_code rtems_timer_delete( Objects_Id id ) { 114548: 55 push %ebp 114549: 89 e5 mov %esp,%ebp 11454b: 53 push %ebx 11454c: 83 ec 18 sub $0x18,%esp /** * 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 11454f: 8d 45 f8 lea -0x8(%ebp),%eax 114552: 50 push %eax 114553: ff 75 08 pushl 0x8(%ebp) 114556: 68 a0 5d 13 00 push $0x135da0 11455b: e8 80 26 00 00 call 116be0 <_Objects_Get> 114560: 89 c3 mov %eax,%ebx Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 114562: 83 c4 10 add $0x10,%esp 114565: 8b 4d f8 mov -0x8(%ebp),%ecx 114568: 85 c9 test %ecx,%ecx 11456a: 75 38 jne 1145a4 case OBJECTS_LOCAL: _Objects_Close( &_Timer_Information, &the_timer->Object ); 11456c: 83 ec 08 sub $0x8,%esp 11456f: 50 push %eax 114570: 68 a0 5d 13 00 push $0x135da0 114575: e8 b2 21 00 00 call 11672c <_Objects_Close> (void) _Watchdog_Remove( &the_timer->Ticker ); 11457a: 8d 43 10 lea 0x10(%ebx),%eax 11457d: 89 04 24 mov %eax,(%esp) 114580: e8 97 42 00 00 call 11881c <_Watchdog_Remove> * @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 114585: 58 pop %eax 114586: 5a pop %edx 114587: 53 push %ebx 114588: 68 a0 5d 13 00 push $0x135da0 11458d: e8 da 24 00 00 call 116a6c <_Objects_Free> _Timer_Free( the_timer ); _Thread_Enable_dispatch(); 114592: e8 8d 2e 00 00 call 117424 <_Thread_Enable_dispatch> 114597: 31 c0 xor %eax,%eax 114599: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11459c: 8b 5d fc mov -0x4(%ebp),%ebx 11459f: c9 leave 1145a0: c3 ret 1145a1: 8d 76 00 lea 0x0(%esi),%esi { Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 1145a4: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1145a9: 8b 5d fc mov -0x4(%ebp),%ebx 1145ac: c9 leave 1145ad: c3 ret =============================================================================== 001145b0 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 1145b0: 55 push %ebp 1145b1: 89 e5 mov %esp,%ebp 1145b3: 57 push %edi 1145b4: 56 push %esi 1145b5: 53 push %ebx 1145b6: 83 ec 1c sub $0x1c,%esp 1145b9: 8b 75 0c mov 0xc(%ebp),%esi Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 1145bc: 85 f6 test %esi,%esi 1145be: 0f 84 98 00 00 00 je 11465c return RTEMS_INVALID_NUMBER; if ( !routine ) 1145c4: 8b 7d 10 mov 0x10(%ebp),%edi 1145c7: 85 ff test %edi,%edi 1145c9: 0f 84 9d 00 00 00 je 11466c <== NEVER TAKEN /** * 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 1145cf: 53 push %ebx 1145d0: 8d 45 f0 lea -0x10(%ebp),%eax 1145d3: 50 push %eax 1145d4: ff 75 08 pushl 0x8(%ebp) 1145d7: 68 a0 5d 13 00 push $0x135da0 1145dc: e8 ff 25 00 00 call 116be0 <_Objects_Get> 1145e1: 89 c3 mov %eax,%ebx return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 1145e3: 83 c4 10 add $0x10,%esp 1145e6: 8b 4d f0 mov -0x10(%ebp),%ecx 1145e9: 85 c9 test %ecx,%ecx 1145eb: 75 5f jne 11464c case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 1145ed: 8d 78 10 lea 0x10(%eax),%edi 1145f0: 83 ec 0c sub $0xc,%esp 1145f3: 57 push %edi 1145f4: e8 23 42 00 00 call 11881c <_Watchdog_Remove> _ISR_Disable( level ); 1145f9: 9c pushf 1145fa: fa cli 1145fb: 58 pop %eax /* * 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 ) { 1145fc: 83 c4 10 add $0x10,%esp 1145ff: 8b 53 18 mov 0x18(%ebx),%edx 114602: 85 d2 test %edx,%edx 114604: 75 76 jne 11467c <== NEVER TAKEN /* * 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; 114606: c7 43 38 00 00 00 00 movl $0x0,0x38(%ebx) * 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. * 11460d: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) * @param[in] the_heap is the heap to operate upon 114614: 8b 55 10 mov 0x10(%ebp),%edx 114617: 89 53 2c mov %edx,0x2c(%ebx) * @param[in] starting_address is the starting address of the memory for 11461a: 8b 55 08 mov 0x8(%ebp),%edx 11461d: 89 53 30 mov %edx,0x30(%ebx) * the heap 114620: 8b 55 14 mov 0x14(%ebp),%edx 114623: 89 53 34 mov %edx,0x34(%ebx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _ISR_Enable( level ); 114626: 50 push %eax 114627: 9d popf * @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, 114628: 89 73 1c mov %esi,0x1c(%ebx) void *starting_address, size_t *size 11462b: 83 ec 08 sub $0x8,%esp 11462e: 57 push %edi 11462f: 68 1c 5b 13 00 push $0x135b1c 114634: e8 b3 40 00 00 call 1186ec <_Watchdog_Insert> _Watchdog_Insert_ticks( &the_timer->Ticker, ticks ); _Thread_Enable_dispatch(); 114639: e8 e6 2d 00 00 call 117424 <_Thread_Enable_dispatch> 11463e: 31 c0 xor %eax,%eax 114640: 83 c4 10 add $0x10,%esp case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114643: 8d 65 f4 lea -0xc(%ebp),%esp 114646: 5b pop %ebx 114647: 5e pop %esi 114648: 5f pop %edi 114649: c9 leave 11464a: c3 ret 11464b: 90 nop if ( !routine ) return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 11464c: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114651: 8d 65 f4 lea -0xc(%ebp),%esp 114654: 5b pop %ebx 114655: 5e pop %esi 114656: 5f pop %edi 114657: c9 leave 114658: c3 ret 114659: 8d 76 00 lea 0x0(%esi),%esi { Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( ticks == 0 ) 11465c: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114661: 8d 65 f4 lea -0xc(%ebp),%esp 114664: 5b pop %ebx 114665: 5e pop %esi 114666: 5f pop %edi 114667: c9 leave 114668: c3 ret 114669: 8d 76 00 lea 0x0(%esi),%esi ISR_Level level; if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; if ( !routine ) 11466c: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114671: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 114674: 5b pop %ebx <== NOT EXECUTED 114675: 5e pop %esi <== NOT EXECUTED 114676: 5f pop %edi <== NOT EXECUTED 114677: c9 leave <== NOT EXECUTED 114678: c3 ret <== NOT EXECUTED 114679: 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 ); 11467c: 50 push %eax <== NOT EXECUTED 11467d: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); 11467e: e8 a1 2d 00 00 call 117424 <_Thread_Enable_dispatch><== NOT EXECUTED 114683: 31 c0 xor %eax,%eax <== NOT EXECUTED 114685: eb ca jmp 114651 <== NOT EXECUTED =============================================================================== 00114688 : Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 114688: 55 push %ebp 114689: 89 e5 mov %esp,%ebp 11468b: 57 push %edi 11468c: 56 push %esi 11468d: 53 push %ebx 11468e: 83 ec 1c sub $0x1c,%esp Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_TOD_Is_set ) 114691: 80 3d 4c 5a 13 00 00 cmpb $0x0,0x135a4c 114698: 75 0e jne 1146a8 11469a: b8 0b 00 00 00 mov $0xb,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11469f: 8d 65 f4 lea -0xc(%ebp),%esp 1146a2: 5b pop %ebx 1146a3: 5e pop %esi 1146a4: 5f pop %edi 1146a5: c9 leave 1146a6: c3 ret 1146a7: 90 nop rtems_interval seconds; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) 1146a8: 83 ec 0c sub $0xc,%esp 1146ab: ff 75 0c pushl 0xc(%ebp) 1146ae: e8 d1 d6 ff ff call 111d84 <_TOD_Validate> 1146b3: 83 c4 10 add $0x10,%esp 1146b6: 84 c0 test %al,%al 1146b8: 74 23 je 1146dd return RTEMS_INVALID_CLOCK; if ( !routine ) 1146ba: 8b 75 10 mov 0x10(%ebp),%esi 1146bd: 85 f6 test %esi,%esi 1146bf: 0f 84 a3 00 00 00 je 114768 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; seconds = _TOD_To_seconds( wall_time ); 1146c5: 83 ec 0c sub $0xc,%esp 1146c8: ff 75 0c pushl 0xc(%ebp) 1146cb: e8 24 d6 ff ff call 111cf4 <_TOD_To_seconds> 1146d0: 89 c7 mov %eax,%edi if ( seconds <= _TOD_Seconds_since_epoch ) 1146d2: 83 c4 10 add $0x10,%esp 1146d5: 3b 05 cc 5a 13 00 cmp 0x135acc,%eax 1146db: 77 0f ja 1146ec _Watchdog_Insert_seconds( &the_timer->Ticker, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 1146dd: b8 14 00 00 00 mov $0x14,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1146e2: 8d 65 f4 lea -0xc(%ebp),%esp 1146e5: 5b pop %ebx 1146e6: 5e pop %esi 1146e7: 5f pop %edi 1146e8: c9 leave 1146e9: c3 ret 1146ea: 66 90 xchg %ax,%ax /** * 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 1146ec: 53 push %ebx 1146ed: 8d 45 f0 lea -0x10(%ebp),%eax 1146f0: 50 push %eax 1146f1: ff 75 08 pushl 0x8(%ebp) 1146f4: 68 a0 5d 13 00 push $0x135da0 1146f9: e8 e2 24 00 00 call 116be0 <_Objects_Get> 1146fe: 89 c6 mov %eax,%esi seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 114700: 83 c4 10 add $0x10,%esp 114703: 8b 4d f0 mov -0x10(%ebp),%ecx 114706: 85 c9 test %ecx,%ecx 114708: 75 52 jne 11475c case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 11470a: 8d 58 10 lea 0x10(%eax),%ebx 11470d: 83 ec 0c sub $0xc,%esp 114710: 53 push %ebx 114711: e8 06 41 00 00 call 11881c <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY; 114716: c7 46 38 02 00 00 00 movl $0x2,0x38(%esi) * 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. * 11471d: c7 46 18 00 00 00 00 movl $0x0,0x18(%esi) * @param[in] the_heap is the heap to operate upon 114724: 8b 45 10 mov 0x10(%ebp),%eax 114727: 89 46 2c mov %eax,0x2c(%esi) * @param[in] starting_address is the starting address of the memory for 11472a: 8b 45 08 mov 0x8(%ebp),%eax 11472d: 89 46 30 mov %eax,0x30(%esi) * the heap 114730: 8b 45 14 mov 0x14(%ebp),%eax 114733: 89 46 34 mov %eax,0x34(%esi) * @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, 114736: 2b 3d cc 5a 13 00 sub 0x135acc,%edi 11473c: 89 7e 1c mov %edi,0x1c(%esi) size_t size ); 11473f: 58 pop %eax 114740: 5a pop %edx 114741: 53 push %ebx 114742: 68 10 5b 13 00 push $0x135b10 114747: e8 a0 3f 00 00 call 1186ec <_Watchdog_Insert> _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); _Watchdog_Insert_seconds( &the_timer->Ticker, seconds - _TOD_Seconds_since_epoch ); _Thread_Enable_dispatch(); 11474c: e8 d3 2c 00 00 call 117424 <_Thread_Enable_dispatch> 114751: 31 c0 xor %eax,%eax 114753: 83 c4 10 add $0x10,%esp 114756: e9 44 ff ff ff jmp 11469f 11475b: 90 nop seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 11475c: b8 04 00 00 00 mov $0x4,%eax 114761: e9 39 ff ff ff jmp 11469f 114766: 66 90 xchg %ax,%ax return RTEMS_NOT_DEFINED; if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; if ( !routine ) 114768: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 11476d: e9 2d ff ff ff jmp 11469f <== NOT EXECUTED =============================================================================== 00114774 : rtems_status_code rtems_timer_get_information( Objects_Id id, rtems_timer_information *the_info ) { 114774: 55 push %ebp 114775: 89 e5 mov %esp,%ebp 114777: 53 push %ebx 114778: 83 ec 14 sub $0x14,%esp 11477b: 8b 5d 0c mov 0xc(%ebp),%ebx Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 11477e: 85 db test %ebx,%ebx 114780: 74 4e je 1147d0 <== NEVER TAKEN /** * 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 114782: 52 push %edx 114783: 8d 45 f8 lea -0x8(%ebp),%eax 114786: 50 push %eax 114787: ff 75 08 pushl 0x8(%ebp) 11478a: 68 a0 5d 13 00 push $0x135da0 11478f: e8 4c 24 00 00 call 116be0 <_Objects_Get> 114794: 89 c2 mov %eax,%edx return RTEMS_INVALID_ADDRESS; the_timer = _Timer_Get( id, &location ); switch ( location ) { 114796: 83 c4 10 add $0x10,%esp 114799: 8b 45 f8 mov -0x8(%ebp),%eax 11479c: 85 c0 test %eax,%eax 11479e: 74 0c je 1147ac 1147a0: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1147a5: 8b 5d fc mov -0x4(%ebp),%ebx 1147a8: c9 leave 1147a9: c3 ret 1147aa: 66 90 xchg %ax,%ax the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: the_info->the_class = the_timer->the_class; 1147ac: 8b 42 38 mov 0x38(%edx),%eax 1147af: 89 03 mov %eax,(%ebx) the_info->initial = the_timer->Ticker.initial; 1147b1: 8b 42 1c mov 0x1c(%edx),%eax 1147b4: 89 43 04 mov %eax,0x4(%ebx) the_info->start_time = the_timer->Ticker.start_time; 1147b7: 8b 42 24 mov 0x24(%edx),%eax 1147ba: 89 43 08 mov %eax,0x8(%ebx) the_info->stop_time = the_timer->Ticker.stop_time; 1147bd: 8b 42 28 mov 0x28(%edx),%eax 1147c0: 89 43 0c mov %eax,0xc(%ebx) _Thread_Enable_dispatch(); 1147c3: e8 5c 2c 00 00 call 117424 <_Thread_Enable_dispatch> 1147c8: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1147ca: 8b 5d fc mov -0x4(%ebp),%ebx 1147cd: c9 leave 1147ce: c3 ret 1147cf: 90 nop ) { Timer_Control *the_timer; Objects_Locations location; if ( !the_info ) 1147d0: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1147d5: 8b 5d fc mov -0x4(%ebp),%ebx <== NOT EXECUTED 1147d8: c9 leave <== NOT EXECUTED 1147d9: c3 ret <== NOT EXECUTED =============================================================================== 00114a84 : rtems_status_code rtems_timer_initiate_server( uint32_t priority, uint32_t stack_size, rtems_attribute attribute_set ) { 114a84: 55 push %ebp 114a85: 89 e5 mov %esp,%ebp 114a87: 56 push %esi 114a88: 53 push %ebx 114a89: 83 ec 10 sub $0x10,%esp 114a8c: 8b 55 08 mov 0x8(%ebp),%edx bool _Protected_heap_Extend( Heap_Control *the_heap, void *starting_address, size_t size ); 114a8f: 85 d2 test %edx,%edx 114a91: 75 0d jne 114aa0 * 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; 114a93: b8 13 00 00 00 mov $0x13,%eax } return status; } 114a98: 8d 65 f8 lea -0x8(%ebp),%esp 114a9b: 5b pop %ebx 114a9c: 5e pop %esi 114a9d: c9 leave 114a9e: c3 ret 114a9f: 90 nop 114aa0: 0f b6 05 14 d1 12 00 movzbl 0x12d114,%eax 114aa7: 39 c2 cmp %eax,%edx 114aa9: 77 31 ja 114adc <== ALWAYS TAKEN 114aab: 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 114aad: a1 38 5a 13 00 mov 0x135a38,%eax 114ab2: 40 inc %eax 114ab3: a3 38 5a 13 00 mov %eax,0x135a38 /* * Just to make sure this is only called once. */ _Thread_Disable_dispatch(); tmpInitialized = initialized; 114ab8: 8a 1d 00 14 13 00 mov 0x131400,%bl initialized = true; 114abe: c6 05 00 14 13 00 01 movb $0x1,0x131400 _Thread_Enable_dispatch(); 114ac5: e8 5a 29 00 00 call 117424 <_Thread_Enable_dispatch> if ( tmpInitialized ) 114aca: 84 db test %bl,%bl 114acc: 74 16 je 114ae4 114ace: b8 0e 00 00 00 mov $0xe,%eax */ initialized = false; } return status; } 114ad3: 8d 65 f8 lea -0x8(%ebp),%esp 114ad6: 5b pop %ebx 114ad7: 5e pop %esi 114ad8: c9 leave 114ad9: c3 ret 114ada: 66 90 xchg %ax,%ax * 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 ) 114adc: 42 inc %edx 114add: 75 b4 jne 114a93 114adf: 31 f6 xor %esi,%esi 114ae1: eb ca jmp 114aad 114ae3: 90 nop 114ae4: c7 05 a0 59 13 00 a4 movl $0x1359a4,0x1359a0 114aeb: 59 13 00 114aee: c7 05 a4 59 13 00 00 movl $0x0,0x1359a4 114af5: 00 00 00 114af8: c7 05 a8 59 13 00 a0 movl $0x1359a0,0x1359a8 114aff: 59 13 00 * 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( 114b02: 83 ec 08 sub $0x8,%esp 114b05: 8d 45 f4 lea -0xc(%ebp),%eax 114b08: 50 push %eax 114b09: 81 4d 10 00 80 00 00 orl $0x8000,0x10(%ebp) 114b10: ff 75 10 pushl 0x10(%ebp) 114b13: 68 00 01 00 00 push $0x100 114b18: ff 75 0c pushl 0xc(%ebp) 114b1b: 56 push %esi 114b1c: 68 45 4d 49 54 push $0x54494d45 114b21: e8 fa f1 ff ff call 113d20 /* 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) { 114b26: 83 c4 20 add $0x20,%esp 114b29: 85 c0 test %eax,%eax 114b2b: 0f 85 b2 00 00 00 jne 114be3 * 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( 114b31: 8b 4d f4 mov -0xc(%ebp),%ecx bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 114b34: 66 3b 0d 50 59 13 00 cmp 0x135950,%cx 114b3b: 0f 86 b3 00 00 00 jbe 114bf4 <== ALWAYS TAKEN 114b41: 31 c0 xor %eax,%eax 114b43: a3 e4 5d 13 00 mov %eax,0x135de4 114b48: c7 05 80 59 13 00 84 movl $0x135984,0x135980 114b4f: 59 13 00 114b52: c7 05 84 59 13 00 00 movl $0x0,0x135984 114b59: 00 00 00 114b5c: c7 05 88 59 13 00 80 movl $0x135980,0x135988 114b63: 59 13 00 114b66: c7 05 94 59 13 00 98 movl $0x135998,0x135994 114b6d: 59 13 00 114b70: c7 05 98 59 13 00 00 movl $0x0,0x135998 114b77: 00 00 00 114b7a: c7 05 9c 59 13 00 94 movl $0x135994,0x13599c 114b81: 59 13 00 * 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. * 114b84: c7 40 50 00 00 00 00 movl $0x0,0x50(%eax) * @param[in] the_heap is the heap to operate upon 114b8b: c7 40 64 8c 72 11 00 movl $0x11728c,0x64(%eax) * @param[in] starting_address is the starting address of the memory for 114b92: 89 48 68 mov %ecx,0x68(%eax) * the heap 114b95: c7 40 6c 00 00 00 00 movl $0x0,0x6c(%eax) * 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. * 114b9c: c7 05 c8 59 13 00 00 movl $0x0,0x1359c8 114ba3: 00 00 00 * @param[in] the_heap is the heap to operate upon 114ba6: c7 05 dc 59 13 00 8c movl $0x11728c,0x1359dc 114bad: 72 11 00 * @param[in] starting_address is the starting address of the memory for 114bb0: 89 0d e0 59 13 00 mov %ecx,0x1359e0 * the heap 114bb6: c7 05 e4 59 13 00 00 movl $0x0,0x1359e4 114bbd: 00 00 00 /* * 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; 114bc0: c7 05 e0 5d 13 00 04 movl $0x114c04,0x135de0 114bc7: 4c 11 00 /* * Start the timer server */ status = rtems_task_start( 114bca: 50 push %eax 114bcb: 6a 00 push $0x0 114bcd: 68 a0 4c 11 00 push $0x114ca0 114bd2: 51 push %ecx 114bd3: e8 5c f6 ff ff call 114234 id, /* the id from create */ (rtems_task_entry) _Timer_Server_body, /* the timer server entry point */ 0 /* there is no argument */ ); if (status) { 114bd8: 83 c4 10 add $0x10,%esp 114bdb: 85 c0 test %eax,%eax 114bdd: 0f 84 b5 fe ff ff je 114a98 <== ALWAYS TAKEN * 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; 114be3: c6 05 00 14 13 00 00 movb $0x0,0x131400 } return status; } 114bea: 8d 65 f8 lea -0x8(%ebp),%esp 114bed: 5b pop %ebx 114bee: 5e pop %esi 114bef: c9 leave 114bf0: c3 ret 114bf1: 8d 76 00 lea 0x0(%esi),%esi bool _Protected_heap_Get_information( Heap_Control *the_heap, Heap_Information_block *the_info ); /** 114bf4: 0f b7 d1 movzwl %cx,%edx 114bf7: a1 5c 59 13 00 mov 0x13595c,%eax 114bfc: 8b 04 90 mov (%eax,%edx,4),%eax 114bff: e9 3f ff ff ff jmp 114b43 =============================================================================== 00114800 : */ rtems_status_code rtems_timer_reset( Objects_Id id ) { 114800: 55 push %ebp 114801: 89 e5 mov %esp,%ebp 114803: 53 push %ebx 114804: 83 ec 18 sub $0x18,%esp 114807: 8d 45 f8 lea -0x8(%ebp),%eax 11480a: 50 push %eax 11480b: ff 75 08 pushl 0x8(%ebp) 11480e: 68 a0 5d 13 00 push $0x135da0 114813: e8 c8 23 00 00 call 116be0 <_Objects_Get> 114818: 89 c3 mov %eax,%ebx Timer_Control *the_timer; Objects_Locations location; the_timer = _Timer_Get( id, &location ); switch ( location ) { 11481a: 83 c4 10 add $0x10,%esp 11481d: 8b 45 f8 mov -0x8(%ebp),%eax 114820: 85 c0 test %eax,%eax 114822: 74 0c je 114830 114824: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114829: 8b 5d fc mov -0x4(%ebp),%ebx 11482c: c9 leave 11482d: c3 ret 11482e: 66 90 xchg %ax,%ax the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: switch ( the_timer->the_class ) { 114830: 8b 43 38 mov 0x38(%ebx),%eax 114833: 83 f8 01 cmp $0x1,%eax 114836: 74 40 je 114878 114838: 73 2a jae 114864 case TIMER_INTERVAL: _Watchdog_Remove( &the_timer->Ticker ); 11483a: 83 c3 10 add $0x10,%ebx 11483d: 83 ec 0c sub $0xc,%esp 114840: 53 push %ebx 114841: e8 d6 3f 00 00 call 11881c <_Watchdog_Remove> _Watchdog_Insert( &_Watchdog_Ticks_chain, &the_timer->Ticker ); 114846: 5a pop %edx 114847: 59 pop %ecx 114848: 53 push %ebx 114849: 68 1c 5b 13 00 push $0x135b1c 11484e: e8 99 3e 00 00 call 1186ec <_Watchdog_Insert> 114853: 83 c4 10 add $0x10,%esp case TIMER_TIME_OF_DAY_ON_TASK: case TIMER_DORMANT: _Thread_Enable_dispatch(); return RTEMS_NOT_DEFINED; } _Thread_Enable_dispatch(); 114856: e8 c9 2b 00 00 call 117424 <_Thread_Enable_dispatch> 11485b: 31 c0 xor %eax,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 11485d: 8b 5d fc mov -0x4(%ebp),%ebx 114860: c9 leave 114861: c3 ret 114862: 66 90 xchg %ax,%ax the_timer = _Timer_Get( id, &location ); switch ( location ) { case OBJECTS_LOCAL: switch ( the_timer->the_class ) { 114864: 83 f8 04 cmp $0x4,%eax 114867: 77 ed ja 114856 <== NEVER TAKEN (*_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(); 114869: e8 b6 2b 00 00 call 117424 <_Thread_Enable_dispatch> 11486e: b8 0b 00 00 00 mov $0xb,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114873: 8b 5d fc mov -0x4(%ebp),%ebx 114876: c9 leave 114877: c3 ret 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 ) { 114878: a1 e0 5d 13 00 mov 0x135de0,%eax 11487d: 85 c0 test %eax,%eax 11487f: 74 1b je 11489c <== NEVER TAKEN _Thread_Enable_dispatch(); return RTEMS_INCORRECT_STATE; } _Watchdog_Remove( &the_timer->Ticker ); 114881: 83 ec 0c sub $0xc,%esp 114884: 8d 43 10 lea 0x10(%ebx),%eax 114887: 50 push %eax 114888: e8 8f 3f 00 00 call 11881c <_Watchdog_Remove> (*_Timer_Server_schedule_operation)( the_timer ); 11488d: 89 1c 24 mov %ebx,(%esp) 114890: ff 15 e0 5d 13 00 call *0x135de0 114896: 83 c4 10 add $0x10,%esp 114899: eb bb jmp 114856 11489b: 90 nop _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(); 11489c: e8 83 2b 00 00 call 117424 <_Thread_Enable_dispatch><== NOT EXECUTED 1148a1: b8 0e 00 00 00 mov $0xe,%eax <== NOT EXECUTED 1148a6: eb 81 jmp 114829 <== NOT EXECUTED =============================================================================== 001148a8 : Objects_Id id, rtems_interval ticks, rtems_timer_service_routine_entry routine, void *user_data ) { 1148a8: 55 push %ebp 1148a9: 89 e5 mov %esp,%ebp 1148ab: 53 push %ebx 1148ac: 83 ec 14 sub $0x14,%esp Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 1148af: a1 e4 5d 13 00 mov 0x135de4,%eax 1148b4: 85 c0 test %eax,%eax 1148b6: 0f 84 b0 00 00 00 je 11496c return RTEMS_INCORRECT_STATE; if ( !routine ) 1148bc: 8b 45 10 mov 0x10(%ebp),%eax 1148bf: 85 c0 test %eax,%eax 1148c1: 0f 84 b1 00 00 00 je 114978 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( ticks == 0 ) 1148c7: 8b 45 0c mov 0xc(%ebp),%eax 1148ca: 85 c0 test %eax,%eax 1148cc: 75 0a jne 1148d8 1148ce: b8 0a 00 00 00 mov $0xa,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1148d3: 8b 5d fc mov -0x4(%ebp),%ebx 1148d6: c9 leave 1148d7: c3 ret 1148d8: 53 push %ebx 1148d9: 8d 45 f8 lea -0x8(%ebp),%eax 1148dc: 50 push %eax 1148dd: ff 75 08 pushl 0x8(%ebp) 1148e0: 68 a0 5d 13 00 push $0x135da0 1148e5: e8 f6 22 00 00 call 116be0 <_Objects_Get> 1148ea: 89 c3 mov %eax,%ebx if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 1148ec: 83 c4 10 add $0x10,%esp 1148ef: 8b 4d f8 mov -0x8(%ebp),%ecx 1148f2: 85 c9 test %ecx,%ecx 1148f4: 75 5a jne 114950 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 1148f6: 83 ec 0c sub $0xc,%esp 1148f9: 8d 40 10 lea 0x10(%eax),%eax 1148fc: 50 push %eax 1148fd: e8 1a 3f 00 00 call 11881c <_Watchdog_Remove> _ISR_Disable( level ); 114902: 9c pushf 114903: fa cli 114904: 58 pop %eax /* * 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 ) { 114905: 83 c4 10 add $0x10,%esp 114908: 8b 53 18 mov 0x18(%ebx),%edx 11490b: 85 d2 test %edx,%edx 11490d: 75 4d jne 11495c <== NEVER TAKEN /* * 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; 11490f: c7 43 38 01 00 00 00 movl $0x1,0x38(%ebx) * 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. * 114916: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) * @param[in] the_heap is the heap to operate upon 11491d: 8b 55 10 mov 0x10(%ebp),%edx 114920: 89 53 2c mov %edx,0x2c(%ebx) * @param[in] starting_address is the starting address of the memory for 114923: 8b 55 08 mov 0x8(%ebp),%edx 114926: 89 53 30 mov %edx,0x30(%ebx) * the heap 114929: 8b 55 14 mov 0x14(%ebp),%edx 11492c: 89 53 34 mov %edx,0x34(%ebx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = ticks; 11492f: 8b 55 0c mov 0xc(%ebp),%edx 114932: 89 53 1c mov %edx,0x1c(%ebx) _ISR_Enable( level ); 114935: 50 push %eax 114936: 9d popf /* * _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 ); 114937: 83 ec 0c sub $0xc,%esp 11493a: 53 push %ebx 11493b: ff 15 e0 5d 13 00 call *0x135de0 _Thread_Enable_dispatch(); 114941: e8 de 2a 00 00 call 117424 <_Thread_Enable_dispatch> 114946: 31 c0 xor %eax,%eax 114948: 83 c4 10 add $0x10,%esp 11494b: eb 86 jmp 1148d3 11494d: 8d 76 00 lea 0x0(%esi),%esi if ( ticks == 0 ) return RTEMS_INVALID_NUMBER; the_timer = _Timer_Get( id, &location ); switch ( location ) { 114950: b8 04 00 00 00 mov $0x4,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114955: 8b 5d fc mov -0x4(%ebp),%ebx 114958: c9 leave 114959: c3 ret 11495a: 66 90 xchg %ax,%ax * 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 ); 11495c: 50 push %eax <== NOT EXECUTED 11495d: 9d popf <== NOT EXECUTED _Thread_Enable_dispatch(); 11495e: e8 c1 2a 00 00 call 117424 <_Thread_Enable_dispatch><== NOT EXECUTED 114963: 31 c0 xor %eax,%eax <== NOT EXECUTED 114965: e9 69 ff ff ff jmp 1148d3 <== NOT EXECUTED 11496a: 66 90 xchg %ax,%ax <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; ISR_Level level; if ( !_Timer_Server ) 11496c: b8 0e 00 00 00 mov $0xe,%eax 114971: e9 5d ff ff ff jmp 1148d3 114976: 66 90 xchg %ax,%ax return RTEMS_INCORRECT_STATE; if ( !routine ) 114978: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 11497d: e9 51 ff ff ff jmp 1148d3 <== NOT EXECUTED =============================================================================== 00114984 : Objects_Id id, rtems_time_of_day *wall_time, rtems_timer_service_routine_entry routine, void *user_data ) { 114984: 55 push %ebp 114985: 89 e5 mov %esp,%ebp 114987: 56 push %esi 114988: 53 push %ebx 114989: 83 ec 10 sub $0x10,%esp Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_Timer_Server ) 11498c: 8b 1d e4 5d 13 00 mov 0x135de4,%ebx 114992: 85 db test %ebx,%ebx 114994: 0f 84 d2 00 00 00 je 114a6c return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 11499a: 80 3d 4c 5a 13 00 00 cmpb $0x0,0x135a4c 1149a1: 0f 84 ad 00 00 00 je 114a54 <== NEVER TAKEN return RTEMS_NOT_DEFINED; if ( !routine ) 1149a7: 8b 4d 10 mov 0x10(%ebp),%ecx 1149aa: 85 c9 test %ecx,%ecx 1149ac: 0f 84 ae 00 00 00 je 114a60 <== NEVER TAKEN return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) 1149b2: 83 ec 0c sub $0xc,%esp 1149b5: ff 75 0c pushl 0xc(%ebp) 1149b8: e8 c7 d3 ff ff call 111d84 <_TOD_Validate> 1149bd: 83 c4 10 add $0x10,%esp 1149c0: 84 c0 test %al,%al 1149c2: 75 0c jne 1149d0 */ (*_Timer_Server_schedule_operation)( the_timer ); _Thread_Enable_dispatch(); return RTEMS_SUCCESSFUL; 1149c4: b8 14 00 00 00 mov $0x14,%eax case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 1149c9: 8d 65 f8 lea -0x8(%ebp),%esp 1149cc: 5b pop %ebx 1149cd: 5e pop %esi 1149ce: c9 leave 1149cf: c3 ret return RTEMS_INVALID_ADDRESS; if ( !_TOD_Validate( wall_time ) ) return RTEMS_INVALID_CLOCK; seconds = _TOD_To_seconds( wall_time ); 1149d0: 83 ec 0c sub $0xc,%esp 1149d3: ff 75 0c pushl 0xc(%ebp) 1149d6: e8 19 d3 ff ff call 111cf4 <_TOD_To_seconds> 1149db: 89 c6 mov %eax,%esi if ( seconds <= _TOD_Seconds_since_epoch ) 1149dd: 83 c4 10 add $0x10,%esp 1149e0: 3b 05 cc 5a 13 00 cmp 0x135acc,%eax 1149e6: 76 dc jbe 1149c4 /** * 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 1149e8: 52 push %edx 1149e9: 8d 45 f4 lea -0xc(%ebp),%eax 1149ec: 50 push %eax 1149ed: ff 75 08 pushl 0x8(%ebp) 1149f0: 68 a0 5d 13 00 push $0x135da0 1149f5: e8 e6 21 00 00 call 116be0 <_Objects_Get> 1149fa: 89 c3 mov %eax,%ebx return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 1149fc: 83 c4 10 add $0x10,%esp 1149ff: 8b 45 f4 mov -0xc(%ebp),%eax 114a02: 85 c0 test %eax,%eax 114a04: 75 72 jne 114a78 case OBJECTS_LOCAL: (void) _Watchdog_Remove( &the_timer->Ticker ); 114a06: 83 ec 0c sub $0xc,%esp 114a09: 8d 43 10 lea 0x10(%ebx),%eax 114a0c: 50 push %eax 114a0d: e8 0a 3e 00 00 call 11881c <_Watchdog_Remove> the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK; 114a12: c7 43 38 03 00 00 00 movl $0x3,0x38(%ebx) * 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. * 114a19: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx) * @param[in] the_heap is the heap to operate upon 114a20: 8b 45 10 mov 0x10(%ebp),%eax 114a23: 89 43 2c mov %eax,0x2c(%ebx) * @param[in] starting_address is the starting address of the memory for 114a26: 8b 45 08 mov 0x8(%ebp),%eax 114a29: 89 43 30 mov %eax,0x30(%ebx) * the heap 114a2c: 8b 45 14 mov 0x14(%ebp),%eax 114a2f: 89 43 34 mov %eax,0x34(%ebx) _Watchdog_Initialize( &the_timer->Ticker, routine, id, user_data ); the_timer->Ticker.initial = seconds - _TOD_Seconds_since_epoch; 114a32: 2b 35 cc 5a 13 00 sub 0x135acc,%esi 114a38: 89 73 1c mov %esi,0x1c(%ebx) /* * _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 ); 114a3b: 89 1c 24 mov %ebx,(%esp) 114a3e: ff 15 e0 5d 13 00 call *0x135de0 _Thread_Enable_dispatch(); 114a44: e8 db 29 00 00 call 117424 <_Thread_Enable_dispatch> 114a49: 31 c0 xor %eax,%eax 114a4b: 83 c4 10 add $0x10,%esp 114a4e: e9 76 ff ff ff jmp 1149c9 114a53: 90 nop rtems_interval seconds; if ( !_Timer_Server ) return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) 114a54: b8 0b 00 00 00 mov $0xb,%eax <== NOT EXECUTED case OBJECTS_ERROR: break; } return RTEMS_INVALID_ID; } 114a59: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 114a5c: 5b pop %ebx <== NOT EXECUTED 114a5d: 5e pop %esi <== NOT EXECUTED 114a5e: c9 leave <== NOT EXECUTED 114a5f: c3 ret <== NOT EXECUTED return RTEMS_INCORRECT_STATE; if ( !_TOD_Is_set ) return RTEMS_NOT_DEFINED; if ( !routine ) 114a60: b8 09 00 00 00 mov $0x9,%eax <== NOT EXECUTED 114a65: e9 5f ff ff ff jmp 1149c9 <== NOT EXECUTED 114a6a: 66 90 xchg %ax,%ax <== NOT EXECUTED { Timer_Control *the_timer; Objects_Locations location; rtems_interval seconds; if ( !_Timer_Server ) 114a6c: b8 0e 00 00 00 mov $0xe,%eax 114a71: e9 53 ff ff ff jmp 1149c9 114a76: 66 90 xchg %ax,%ax seconds = _TOD_To_seconds( wall_time ); if ( seconds <= _TOD_Seconds_since_epoch ) return RTEMS_INVALID_CLOCK; the_timer = _Timer_Get( id, &location ); switch ( location ) { 114a78: b8 04 00 00 00 mov $0x4,%eax 114a7d: e9 47 ff ff ff jmp 1149c9 =============================================================================== 00107b14 : static int rtems_verror( uint32_t error_flag, const char *printf_format, va_list arglist ) { 107b14: 55 push %ebp <== NOT EXECUTED 107b15: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107b17: 57 push %edi <== NOT EXECUTED 107b18: 56 push %esi <== NOT EXECUTED 107b19: 53 push %ebx <== NOT EXECUTED 107b1a: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107b1d: 89 c6 mov %eax,%esi <== NOT EXECUTED 107b1f: 89 55 e8 mov %edx,-0x18(%ebp) <== NOT EXECUTED 107b22: 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) 107b24: 25 00 00 00 20 and $0x20000000,%eax <== NOT EXECUTED 107b29: 89 45 ec mov %eax,-0x14(%ebp) <== NOT EXECUTED 107b2c: 74 2a je 107b58 <== NOT EXECUTED { if (rtems_panic_in_progress++) 107b2e: 8b 15 f0 a4 12 00 mov 0x12a4f0,%edx <== NOT EXECUTED 107b34: 8d 42 01 lea 0x1(%edx),%eax <== NOT EXECUTED 107b37: a3 f0 a4 12 00 mov %eax,0x12a4f0 <== NOT EXECUTED 107b3c: 85 d2 test %edx,%edx <== NOT EXECUTED 107b3e: 74 0b je 107b4b <== NOT EXECUTED 107b40: a1 78 a6 12 00 mov 0x12a678,%eax <== NOT EXECUTED 107b45: 40 inc %eax <== NOT EXECUTED 107b46: a3 78 a6 12 00 mov %eax,0x12a678 <== NOT EXECUTED _Thread_Disable_dispatch(); /* disable task switches */ /* don't aggravate things */ if (rtems_panic_in_progress > 2) 107b4b: 83 3d f0 a4 12 00 02 cmpl $0x2,0x12a4f0 <== NOT EXECUTED 107b52: 0f 8f dc 00 00 00 jg 107c34 <== NOT EXECUTED return 0; } (void) fflush(stdout); /* in case stdout/stderr same */ 107b58: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107b5b: a1 e0 07 12 00 mov 0x1207e0,%eax <== NOT EXECUTED 107b60: ff 70 08 pushl 0x8(%eax) <== NOT EXECUTED 107b63: e8 bc 9f 00 00 call 111b24 <== NOT EXECUTED status = error_flag & ~RTEMS_ERROR_MASK; 107b68: 89 f3 mov %esi,%ebx <== NOT EXECUTED 107b6a: 81 e3 ff ff ff 8f and $0x8fffffff,%ebx <== NOT EXECUTED if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */ 107b70: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107b73: f7 c6 00 00 00 40 test $0x40000000,%esi <== NOT EXECUTED 107b79: 0f 85 c1 00 00 00 jne 107c40 <== NOT EXECUTED 107b7f: 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); 107b86: 50 push %eax <== NOT EXECUTED 107b87: 57 push %edi <== NOT EXECUTED 107b88: ff 75 e8 pushl -0x18(%ebp) <== NOT EXECUTED 107b8b: a1 e0 07 12 00 mov 0x1207e0,%eax <== NOT EXECUTED 107b90: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 107b93: e8 74 e8 00 00 call 11640c <== NOT EXECUTED 107b98: 89 c7 mov %eax,%edi <== NOT EXECUTED if (status) 107b9a: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107b9d: 85 db test %ebx,%ebx <== NOT EXECUTED 107b9f: 0f 85 b7 00 00 00 jne 107c5c <== NOT EXECUTED chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); if (local_errno) 107ba5: 83 7d f0 00 cmpl $0x0,-0x10(%ebp) <== NOT EXECUTED 107ba9: 74 34 je 107bdf <== NOT EXECUTED { if ((local_errno > 0) && *strerror(local_errno)) 107bab: 7e 17 jle 107bc4 <== NOT EXECUTED 107bad: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107bb0: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 107bb3: e8 a4 af 00 00 call 112b5c <== NOT EXECUTED 107bb8: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107bbb: 80 38 00 cmpb $0x0,(%eax) <== NOT EXECUTED 107bbe: 0f 85 c8 00 00 00 jne 107c8c <== NOT EXECUTED chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno)); else chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno); 107bc4: 53 push %ebx <== NOT EXECUTED 107bc5: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 107bc8: 68 32 b2 11 00 push $0x11b232 <== NOT EXECUTED 107bcd: a1 e0 07 12 00 mov 0x1207e0,%eax <== NOT EXECUTED 107bd2: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 107bd5: e8 fa a2 00 00 call 111ed4 <== NOT EXECUTED 107bda: 01 c7 add %eax,%edi <== NOT EXECUTED 107bdc: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } chars_written += fprintf(stderr, "\n"); 107bdf: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107be2: 68 ab a6 11 00 push $0x11a6ab <== NOT EXECUTED 107be7: a1 e0 07 12 00 mov 0x1207e0,%eax <== NOT EXECUTED 107bec: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 107bef: e8 e0 a2 00 00 call 111ed4 <== NOT EXECUTED 107bf4: 89 c3 mov %eax,%ebx <== NOT EXECUTED (void) fflush(stderr); 107bf6: 59 pop %ecx <== NOT EXECUTED 107bf7: a1 e0 07 12 00 mov 0x1207e0,%eax <== NOT EXECUTED 107bfc: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 107bff: e8 20 9f 00 00 call 111b24 <== NOT EXECUTED if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT)) 107c04: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107c07: 81 e6 00 00 00 30 and $0x30000000,%esi <== NOT EXECUTED 107c0d: 74 41 je 107c50 <== NOT EXECUTED { if (error_flag & RTEMS_ERROR_PANIC) 107c0f: 8b 55 ec mov -0x14(%ebp),%edx <== NOT EXECUTED 107c12: 85 d2 test %edx,%edx <== NOT EXECUTED 107c14: 0f 84 8b 00 00 00 je 107ca5 <== NOT EXECUTED { rtems_error(0, "fatal error, exiting"); 107c1a: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107c1d: 68 46 b2 11 00 push $0x11b246 <== NOT EXECUTED 107c22: 6a 00 push $0x0 <== NOT EXECUTED 107c24: e8 ab 00 00 00 call 107cd4 <== NOT EXECUTED _exit(local_errno); 107c29: 58 pop %eax <== NOT EXECUTED 107c2a: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 107c2d: e8 1e 07 00 00 call 108350 <_exit> <== NOT EXECUTED 107c32: 66 90 xchg %ax,%ax <== NOT EXECUTED } else { rtems_error(0, "fatal error, aborting"); abort(); 107c34: 31 c0 xor %eax,%eax <== NOT EXECUTED } } return chars_written; } 107c36: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107c39: 5b pop %ebx <== NOT EXECUTED 107c3a: 5e pop %esi <== NOT EXECUTED 107c3b: 5f pop %edi <== NOT EXECUTED 107c3c: c9 leave <== NOT EXECUTED 107c3d: c3 ret <== NOT EXECUTED 107c3e: 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; 107c40: e8 2f 9c 00 00 call 111874 <__errno> <== NOT EXECUTED 107c45: 8b 00 mov (%eax),%eax <== NOT EXECUTED 107c47: 89 45 f0 mov %eax,-0x10(%ebp) <== NOT EXECUTED 107c4a: e9 37 ff ff ff jmp 107b86 <== NOT EXECUTED 107c4f: 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"); 107c50: 8d 04 3b lea (%ebx,%edi,1),%eax <== NOT EXECUTED rtems_error(0, "fatal error, aborting"); abort(); } } return chars_written; } 107c53: 8d 65 f4 lea -0xc(%ebp),%esp <== NOT EXECUTED 107c56: 5b pop %ebx <== NOT EXECUTED 107c57: 5e pop %esi <== NOT EXECUTED 107c58: 5f pop %edi <== NOT EXECUTED 107c59: c9 leave <== NOT EXECUTED 107c5a: c3 ret <== NOT EXECUTED 107c5b: 90 nop <== NOT EXECUTED const char * rtems_status_text( rtems_status_code status ) { return rtems_assoc_name_by_local(rtems_status_assoc, status); 107c5c: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107c5f: 53 push %ebx <== NOT EXECUTED 107c60: 68 40 b5 11 00 push $0x11b540 <== NOT EXECUTED 107c65: e8 8e 7f 00 00 call 10fbf8 <== NOT EXECUTED #endif chars_written += vfprintf(stderr, printf_format, arglist); if (status) chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status)); 107c6a: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 107c6d: 50 push %eax <== NOT EXECUTED 107c6e: 68 17 b2 11 00 push $0x11b217 <== NOT EXECUTED 107c73: a1 e0 07 12 00 mov 0x1207e0,%eax <== NOT EXECUTED 107c78: ff 70 0c pushl 0xc(%eax) <== NOT EXECUTED 107c7b: e8 54 a2 00 00 call 111ed4 <== NOT EXECUTED 107c80: 01 c7 add %eax,%edi <== NOT EXECUTED 107c82: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107c85: e9 1b ff ff ff jmp 107ba5 <== NOT EXECUTED 107c8a: 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)); 107c8c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107c8f: ff 75 f0 pushl -0x10(%ebp) <== NOT EXECUTED 107c92: e8 c5 ae 00 00 call 112b5c <== NOT EXECUTED 107c97: 83 c4 0c add $0xc,%esp <== NOT EXECUTED 107c9a: 50 push %eax <== NOT EXECUTED 107c9b: 68 25 b2 11 00 push $0x11b225 <== NOT EXECUTED 107ca0: e9 28 ff ff ff jmp 107bcd <== NOT EXECUTED rtems_error(0, "fatal error, exiting"); _exit(local_errno); } else { rtems_error(0, "fatal error, aborting"); 107ca5: 83 ec 08 sub $0x8,%esp <== NOT EXECUTED 107ca8: 68 5b b2 11 00 push $0x11b25b <== NOT EXECUTED 107cad: 6a 00 push $0x0 <== NOT EXECUTED 107caf: e8 20 00 00 00 call 107cd4 <== NOT EXECUTED abort(); 107cb4: e8 87 9b 00 00 call 111840 <== NOT EXECUTED =============================================================================== 00108b30 : /* * Process input character, with semaphore. */ static int siproc (unsigned char c, struct rtems_termios_tty *tty) { 108b30: 55 push %ebp <== NOT EXECUTED 108b31: 89 e5 mov %esp,%ebp <== NOT EXECUTED 108b33: 56 push %esi <== NOT EXECUTED 108b34: 53 push %ebx <== NOT EXECUTED 108b35: 89 d6 mov %edx,%esi <== NOT EXECUTED 108b37: 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)) { 108b39: f7 42 3c 78 0e 00 00 testl $0xe78,0x3c(%edx) <== NOT EXECUTED 108b40: 75 0e jne 108b50 <== 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); 108b42: 0f b6 c0 movzbl %al,%eax <== NOT EXECUTED } return i; } 108b45: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108b48: 5b pop %ebx <== NOT EXECUTED 108b49: 5e pop %esi <== NOT EXECUTED 108b4a: 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); 108b4b: e9 a8 fe ff ff jmp 1089f8 <== 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); 108b50: 50 push %eax <== NOT EXECUTED 108b51: 6a 00 push $0x0 <== NOT EXECUTED 108b53: 6a 00 push $0x0 <== NOT EXECUTED 108b55: ff 72 18 pushl 0x18(%edx) <== NOT EXECUTED 108b58: e8 93 18 00 00 call 10a3f0 <== NOT EXECUTED i = iproc (c, tty); 108b5d: 0f b6 c3 movzbl %bl,%eax <== NOT EXECUTED 108b60: 89 f2 mov %esi,%edx <== NOT EXECUTED 108b62: e8 91 fe ff ff call 1089f8 <== NOT EXECUTED 108b67: 89 c3 mov %eax,%ebx <== NOT EXECUTED rtems_semaphore_release (tty->osem); 108b69: 59 pop %ecx <== NOT EXECUTED 108b6a: ff 76 18 pushl 0x18(%esi) <== NOT EXECUTED 108b6d: e8 76 19 00 00 call 10a4e8 <== NOT EXECUTED 108b72: 83 c4 10 add $0x10,%esp <== NOT EXECUTED } else { i = iproc (c, tty); } return i; } 108b75: 89 d8 mov %ebx,%eax <== NOT EXECUTED 108b77: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 108b7a: 5b pop %ebx <== NOT EXECUTED 108b7b: 5e pop %esi <== NOT EXECUTED 108b7c: c9 leave <== NOT EXECUTED 108b7d: c3 ret <== NOT EXECUTED =============================================================================== 00107e50 : #include int termios_baud_to_number( int termios_baud ) { 107e50: 55 push %ebp <== NOT EXECUTED 107e51: 89 e5 mov %esp,%ebp <== NOT EXECUTED 107e53: 8b 45 08 mov 0x8(%ebp),%eax <== NOT EXECUTED int baud; switch (termios_baud) { 107e56: 83 f8 09 cmp $0x9,%eax <== NOT EXECUTED 107e59: 0f 84 f1 00 00 00 je 107f50 <== NOT EXECUTED 107e5f: 7e 37 jle 107e98 <== NOT EXECUTED 107e61: 83 f8 0e cmp $0xe,%eax <== NOT EXECUTED 107e64: 0f 84 f6 00 00 00 je 107f60 <== NOT EXECUTED 107e6a: 7e 5c jle 107ec8 <== NOT EXECUTED 107e6c: 3d 02 10 00 00 cmp $0x1002,%eax <== NOT EXECUTED 107e71: 0f 84 01 01 00 00 je 107f78 <== NOT EXECUTED 107e77: 0f 8e 97 00 00 00 jle 107f14 <== NOT EXECUTED 107e7d: 3d 03 10 00 00 cmp $0x1003,%eax <== NOT EXECUTED 107e82: 0f 84 e0 00 00 00 je 107f68 <== NOT EXECUTED 107e88: 3d 04 10 00 00 cmp $0x1004,%eax <== NOT EXECUTED 107e8d: 75 51 jne 107ee0 <== 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; 107e8f: b8 00 08 07 00 mov $0x70800,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107e94: c9 leave <== NOT EXECUTED 107e95: c3 ret <== NOT EXECUTED 107e96: 66 90 xchg %ax,%ax <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107e98: 83 f8 04 cmp $0x4,%eax <== NOT EXECUTED 107e9b: 0f 84 b7 00 00 00 je 107f58 <== NOT EXECUTED 107ea1: 7f 45 jg 107ee8 <== NOT EXECUTED 107ea3: 83 f8 01 cmp $0x1,%eax <== NOT EXECUTED 107ea6: 0f 84 8c 00 00 00 je 107f38 <== NOT EXECUTED 107eac: 0f 8e de 00 00 00 jle 107f90 <== NOT EXECUTED 107eb2: 83 f8 02 cmp $0x2,%eax <== NOT EXECUTED 107eb5: 0f 84 c5 00 00 00 je 107f80 <== NOT EXECUTED 107ebb: 83 f8 03 cmp $0x3,%eax <== NOT EXECUTED 107ebe: 75 20 jne 107ee0 <== NOT EXECUTED case B0: baud = 0; break; case B50: baud = 50; break; case B75: baud = 75; break; 107ec0: b8 6e 00 00 00 mov $0x6e,%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 int termios_baud ) { int baud; switch (termios_baud) { 107ec8: 83 f8 0b cmp $0xb,%eax <== NOT EXECUTED 107ecb: 0f 84 9f 00 00 00 je 107f70 <== NOT EXECUTED 107ed1: 7c 39 jl 107f0c <== NOT EXECUTED 107ed3: 83 f8 0c cmp $0xc,%eax <== NOT EXECUTED 107ed6: 74 50 je 107f28 <== NOT EXECUTED 107ed8: 83 f8 0d cmp $0xd,%eax <== NOT EXECUTED 107edb: 74 62 je 107f3f <== NOT EXECUTED 107edd: 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; 107ee0: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED default: baud = -1; break; } return baud; } 107ee5: c9 leave <== NOT EXECUTED 107ee6: c3 ret <== NOT EXECUTED 107ee7: 90 nop <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107ee8: 83 f8 06 cmp $0x6,%eax <== NOT EXECUTED 107eeb: 74 43 je 107f30 <== NOT EXECUTED 107eed: 7c 15 jl 107f04 <== NOT EXECUTED 107eef: 83 f8 07 cmp $0x7,%eax <== NOT EXECUTED 107ef2: 0f 84 90 00 00 00 je 107f88 <== NOT EXECUTED 107ef8: 83 f8 08 cmp $0x8,%eax <== NOT EXECUTED 107efb: 75 e3 jne 107ee0 <== 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; 107efd: b8 58 02 00 00 mov $0x258,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f02: c9 leave <== NOT EXECUTED 107f03: 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; 107f04: b8 96 00 00 00 mov $0x96,%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 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; 107f0c: b8 08 07 00 00 mov $0x708,%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 int termios_baud ) { int baud; switch (termios_baud) { 107f14: 83 f8 0f cmp $0xf,%eax <== NOT EXECUTED 107f17: 74 2f je 107f48 <== NOT EXECUTED 107f19: 3d 01 10 00 00 cmp $0x1001,%eax <== NOT EXECUTED 107f1e: 75 c0 jne 107ee0 <== 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; 107f20: b8 00 e1 00 00 mov $0xe100,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f25: c9 leave <== NOT EXECUTED 107f26: c3 ret <== NOT EXECUTED 107f27: 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; 107f28: b8 c0 12 00 00 mov $0x12c0,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f2d: c9 leave <== NOT EXECUTED 107f2e: c3 ret <== NOT EXECUTED 107f2f: 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; 107f30: b8 c8 00 00 00 mov $0xc8,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f35: c9 leave <== NOT EXECUTED 107f36: c3 ret <== NOT EXECUTED 107f37: 90 nop <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107f38: b8 32 00 00 00 mov $0x32,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f3d: c9 leave <== NOT EXECUTED 107f3e: 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; 107f3f: b8 80 25 00 00 mov $0x2580,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f44: c9 leave <== NOT EXECUTED 107f45: c3 ret <== NOT EXECUTED 107f46: 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; 107f48: b8 00 96 00 00 mov $0x9600,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f4d: c9 leave <== NOT EXECUTED 107f4e: c3 ret <== NOT EXECUTED 107f4f: 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; 107f50: b8 b0 04 00 00 mov $0x4b0,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f55: c9 leave <== NOT EXECUTED 107f56: c3 ret <== NOT EXECUTED 107f57: 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; 107f58: b8 87 00 00 00 mov $0x87,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f5d: c9 leave <== NOT EXECUTED 107f5e: c3 ret <== NOT EXECUTED 107f5f: 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; 107f60: b8 00 4b 00 00 mov $0x4b00,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f65: c9 leave <== NOT EXECUTED 107f66: c3 ret <== NOT EXECUTED 107f67: 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; 107f68: b8 00 84 03 00 mov $0x38400,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f6d: c9 leave <== NOT EXECUTED 107f6e: c3 ret <== NOT EXECUTED 107f6f: 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; 107f70: b8 60 09 00 00 mov $0x960,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f75: c9 leave <== NOT EXECUTED 107f76: c3 ret <== NOT EXECUTED 107f77: 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; 107f78: b8 00 c2 01 00 mov $0x1c200,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f7d: c9 leave <== NOT EXECUTED 107f7e: c3 ret <== NOT EXECUTED 107f7f: 90 nop <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107f80: b8 4b 00 00 00 mov $0x4b,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f85: c9 leave <== NOT EXECUTED 107f86: c3 ret <== NOT EXECUTED 107f87: 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; 107f88: b8 2c 01 00 00 mov $0x12c,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f8d: c9 leave <== NOT EXECUTED 107f8e: c3 ret <== NOT EXECUTED 107f8f: 90 nop <== NOT EXECUTED int termios_baud ) { int baud; switch (termios_baud) { 107f90: 85 c0 test %eax,%eax <== NOT EXECUTED 107f92: 0f 85 48 ff ff ff jne 107ee0 <== NOT EXECUTED 107f98: 31 c0 xor %eax,%eax <== NOT EXECUTED case B460800: baud = 460800; break; default: baud = -1; break; } return baud; } 107f9a: c9 leave <== NOT EXECUTED 107f9b: c3 ret <== NOT EXECUTED =============================================================================== 00107b20 : */ void vprintk( const char *fmt, va_list ap ) { 107b20: 55 push %ebp 107b21: 89 e5 mov %esp,%ebp 107b23: 57 push %edi 107b24: 56 push %esi 107b25: 53 push %ebx 107b26: 83 ec 3c sub $0x3c,%esp 107b29: 8b 7d 0c mov 0xc(%ebp),%edi char c, *str; int lflag, base, sign, width, lead, minus; for (; *fmt != '\0'; fmt++) { 107b2c: 8b 55 08 mov 0x8(%ebp),%edx 107b2f: 8a 02 mov (%edx),%al 107b31: 84 c0 test %al,%al 107b33: 0f 84 b9 00 00 00 je 107bf2 <== NEVER TAKEN base = 0; sign = 0; width = 0; minus = 0; lead = ' '; if (*fmt == '%') { 107b39: 3c 25 cmp $0x25,%al 107b3b: 0f 85 92 00 00 00 jne 107bd3 107b41: 8d 76 00 lea 0x0(%esi),%esi fmt++; 107b44: 8b 4d 08 mov 0x8(%ebp),%ecx 107b47: 41 inc %ecx if (*fmt == '0' ) { 107b48: 8b 45 08 mov 0x8(%ebp),%eax 107b4b: 8a 50 01 mov 0x1(%eax),%dl 107b4e: 80 fa 30 cmp $0x30,%dl 107b51: 0f 84 91 02 00 00 je 107de8 107b57: c7 45 c4 20 00 00 00 movl $0x20,-0x3c(%ebp) lead = '0'; fmt++; } if (*fmt == '-' ) { 107b5e: 80 fa 2d cmp $0x2d,%dl 107b61: 0f 84 59 02 00 00 je 107dc0 107b67: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) minus = 1; fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { 107b6e: 8d 42 d0 lea -0x30(%edx),%eax 107b71: 3c 09 cmp $0x9,%al 107b73: 0f 87 5c 02 00 00 ja 107dd5 107b79: 31 db xor %ebx,%ebx 107b7b: 90 nop width *= 10; width += (*fmt - '0'); 107b7c: 8d 04 9b lea (%ebx,%ebx,4),%eax 107b7f: 0f be d2 movsbl %dl,%edx 107b82: 8d 5c 42 d0 lea -0x30(%edx,%eax,2),%ebx fmt++; 107b86: 41 inc %ecx } if (*fmt == '-' ) { minus = 1; fmt++; } while (*fmt >= '0' && *fmt <= '9' ) { 107b87: 8a 11 mov (%ecx),%dl 107b89: 8d 42 d0 lea -0x30(%edx),%eax 107b8c: 3c 09 cmp $0x9,%al 107b8e: 76 ec jbe 107b7c 107b90: 89 5d d0 mov %ebx,-0x30(%ebp) 107b93: 89 4d 08 mov %ecx,0x8(%ebp) width *= 10; width += (*fmt - '0'); fmt++; } if ((c = *fmt) == 'l') { 107b96: 80 fa 6c cmp $0x6c,%dl 107b99: 0f 84 11 02 00 00 je 107db0 lflag = 1; c = *++fmt; } switch (c) { 107b9f: 8d 42 bc lea -0x44(%edx),%eax 107ba2: 3c 34 cmp $0x34,%al 107ba4: 76 56 jbe 107bfc break; case 'c': BSP_output_char(va_arg(ap, int)); break; default: BSP_output_char(c); 107ba6: 83 ec 0c sub $0xc,%esp 107ba9: 0f be c2 movsbl %dl,%eax 107bac: 50 push %eax 107bad: ff 15 a4 a1 11 00 call *0x11a1a4 107bb3: 89 7d cc mov %edi,-0x34(%ebp) 107bb6: 83 c4 10 add $0x10,%esp 107bb9: 8d 76 00 lea 0x0(%esi),%esi ) { char c, *str; int lflag, base, sign, width, lead, minus; for (; *fmt != '\0'; fmt++) { 107bbc: ff 45 08 incl 0x8(%ebp) 107bbf: 8b 55 08 mov 0x8(%ebp),%edx 107bc2: 8a 02 mov (%edx),%al 107bc4: 84 c0 test %al,%al 107bc6: 74 2a je 107bf2 <== NEVER TAKEN 107bc8: 8b 7d cc mov -0x34(%ebp),%edi base = 0; sign = 0; width = 0; minus = 0; lead = ' '; if (*fmt == '%') { 107bcb: 3c 25 cmp $0x25,%al 107bcd: 0f 84 71 ff ff ff je 107b44 if (base) printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int), base, sign, width, lead); } else { BSP_output_char(*fmt); 107bd3: 83 ec 0c sub $0xc,%esp 107bd6: 0f be c0 movsbl %al,%eax 107bd9: 50 push %eax 107bda: ff 15 a4 a1 11 00 call *0x11a1a4 107be0: 89 7d cc mov %edi,-0x34(%ebp) 107be3: 83 c4 10 add $0x10,%esp ) { char c, *str; int lflag, base, sign, width, lead, minus; for (; *fmt != '\0'; fmt++) { 107be6: ff 45 08 incl 0x8(%ebp) 107be9: 8b 55 08 mov 0x8(%ebp),%edx 107bec: 8a 02 mov (%edx),%al 107bee: 84 c0 test %al,%al 107bf0: 75 d6 jne 107bc8 base, sign, width, lead); } else { BSP_output_char(*fmt); } } } 107bf2: 8d 65 f4 lea -0xc(%ebp),%esp 107bf5: 5b pop %ebx 107bf6: 5e pop %esi 107bf7: 5f pop %edi 107bf8: c9 leave 107bf9: c3 ret 107bfa: 66 90 xchg %ax,%ax if ((c = *fmt) == 'l') { lflag = 1; c = *++fmt; } switch (c) { 107bfc: 0f b6 c0 movzbl %al,%eax 107bff: ff 24 85 e4 84 11 00 jmp *0x1184e4(,%eax,4) break; case 'c': BSP_output_char(va_arg(ap, int)); break; default: BSP_output_char(c); 107c06: 31 c0 xor %eax,%eax 107c08: 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), 107c0d: 8d 57 04 lea 0x4(%edi),%edx 107c10: 89 55 cc mov %edx,-0x34(%ebp) 107c13: 8b 1f mov (%edi),%ebx { long unsigned int n; int count; char toPrint[20]; if ( (sign == 1) && ((long)num < 0) ) { 107c15: 48 dec %eax 107c16: 0f 84 a4 00 00 00 je 107cc0 <== NEVER TAKEN num = -num; if (maxwidth) maxwidth--; } count = 0; while ((n = num / base) > 0) { 107c1c: 89 d8 mov %ebx,%eax 107c1e: 31 d2 xor %edx,%edx 107c20: f7 f6 div %esi 107c22: 85 c0 test %eax,%eax 107c24: 0f 84 c4 00 00 00 je 107cee 107c2a: 89 d9 mov %ebx,%ecx 107c2c: 89 c3 mov %eax,%ebx 107c2e: 31 ff xor %edi,%edi 107c30: eb 06 jmp 107c38 107c32: 66 90 xchg %ax,%ax 107c34: 89 d9 mov %ebx,%ecx 107c36: 89 c3 mov %eax,%ebx toPrint[count++] = (num - (n*base)); 107c38: 89 d8 mov %ebx,%eax 107c3a: 0f af c6 imul %esi,%eax 107c3d: 28 c1 sub %al,%cl 107c3f: 88 4c 3d e0 mov %cl,-0x20(%ebp,%edi,1) 107c43: 47 inc %edi num = -num; if (maxwidth) maxwidth--; } count = 0; while ((n = num / base) > 0) { 107c44: 89 d8 mov %ebx,%eax 107c46: 31 d2 xor %edx,%edx 107c48: f7 f6 div %esi 107c4a: 85 c0 test %eax,%eax 107c4c: 75 e6 jne 107c34 107c4e: 8d 77 01 lea 0x1(%edi),%esi toPrint[count++] = (num - (n*base)); num = n; } toPrint[count++] = num; 107c51: 88 5c 3d e0 mov %bl,-0x20(%ebp,%edi,1) for (n=maxwidth ; n > count; n-- ) 107c55: 8b 5d d0 mov -0x30(%ebp),%ebx 107c58: 39 f3 cmp %esi,%ebx 107c5a: 76 16 jbe 107c72 107c5c: 0f be 7d c4 movsbl -0x3c(%ebp),%edi BSP_output_char(lead); 107c60: 83 ec 0c sub $0xc,%esp 107c63: 57 push %edi 107c64: ff 15 a4 a1 11 00 call *0x11a1a4 toPrint[count++] = (num - (n*base)); num = n; } toPrint[count++] = num; for (n=maxwidth ; n > count; n-- ) 107c6a: 4b dec %ebx 107c6b: 83 c4 10 add $0x10,%esp 107c6e: 39 f3 cmp %esi,%ebx 107c70: 77 ee ja 107c60 BSP_output_char(lead); for (n = 0; n < count; n++) { 107c72: 85 f6 test %esi,%esi 107c74: 0f 84 42 ff ff ff je 107bbc <== NEVER TAKEN 107c7a: 31 db xor %ebx,%ebx 107c7c: 8d 7c 35 f4 lea -0xc(%ebp,%esi,1),%edi BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]); 107c80: 83 ec 0c sub $0xc,%esp 107c83: 89 d8 mov %ebx,%eax 107c85: f7 d0 not %eax 107c87: 0f be 44 38 ec movsbl -0x14(%eax,%edi,1),%eax 107c8c: 0f be 80 d2 84 11 00 movsbl 0x1184d2(%eax),%eax 107c93: 50 push %eax 107c94: ff 15 a4 a1 11 00 call *0x11a1a4 toPrint[count++] = num; for (n=maxwidth ; n > count; n-- ) BSP_output_char(lead); for (n = 0; n < count; n++) { 107c9a: 43 inc %ebx 107c9b: 83 c4 10 add $0x10,%esp 107c9e: 39 de cmp %ebx,%esi 107ca0: 77 de ja 107c80 107ca2: e9 15 ff ff ff jmp 107bbc if ((c = *fmt) == 'l') { lflag = 1; c = *++fmt; } switch (c) { 107ca7: b8 01 00 00 00 mov $0x1,%eax 107cac: be 0a 00 00 00 mov $0xa,%esi BSP_output_char(c); break; } /* switch*/ if (base) printNum(lflag ? va_arg(ap, long int) : (long int)va_arg(ap, int), 107cb1: 8d 57 04 lea 0x4(%edi),%edx 107cb4: 89 55 cc mov %edx,-0x34(%ebp) 107cb7: 8b 1f mov (%edi),%ebx { long unsigned int n; int count; char toPrint[20]; if ( (sign == 1) && ((long)num < 0) ) { 107cb9: 48 dec %eax 107cba: 0f 85 5c ff ff ff jne 107c1c <== NEVER TAKEN 107cc0: 85 db test %ebx,%ebx 107cc2: 0f 89 54 ff ff ff jns 107c1c <== ALWAYS TAKEN BSP_output_char('-'); 107cc8: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107ccb: 6a 2d push $0x2d <== NOT EXECUTED 107ccd: ff 15 a4 a1 11 00 call *0x11a1a4 <== NOT EXECUTED num = -num; 107cd3: f7 db neg %ebx <== NOT EXECUTED if (maxwidth) maxwidth--; 107cd5: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107cd8: 83 7d d0 01 cmpl $0x1,-0x30(%ebp) <== NOT EXECUTED 107cdc: 83 55 d0 ff adcl $0xffffffff,-0x30(%ebp) <== NOT EXECUTED } count = 0; while ((n = num / base) > 0) { 107ce0: 89 d8 mov %ebx,%eax <== NOT EXECUTED 107ce2: 31 d2 xor %edx,%edx <== NOT EXECUTED 107ce4: f7 f6 div %esi <== NOT EXECUTED 107ce6: 85 c0 test %eax,%eax <== NOT EXECUTED 107ce8: 0f 85 3c ff ff ff jne 107c2a <== NOT EXECUTED 107cee: 31 ff xor %edi,%edi 107cf0: be 01 00 00 00 mov $0x1,%esi 107cf5: e9 57 ff ff ff jmp 107c51 case 'p': base = 16; sign = 0; break; case 's': { int i, len; char *s; str = va_arg(ap, char *); 107cfa: 8d 47 04 lea 0x4(%edi),%eax 107cfd: 89 45 cc mov %eax,-0x34(%ebp) 107d00: 8b 3f mov (%edi),%edi 107d02: 89 7d c0 mov %edi,-0x40(%ebp) /* calculate length of string */ for ( len=0, s=str ; *s ; len++, s++ ) 107d05: 80 3f 00 cmpb $0x0,(%edi) 107d08: 0f 84 16 01 00 00 je 107e24 <== NEVER TAKEN 107d0e: 31 ff xor %edi,%edi 107d10: 47 inc %edi 107d11: 8b 55 c0 mov -0x40(%ebp),%edx 107d14: 80 3c 3a 00 cmpb $0x0,(%edx,%edi,1) 107d18: 75 f6 jne 107d10 ; /* leading spaces */ if ( !minus ) 107d1a: 8b 4d c8 mov -0x38(%ebp),%ecx 107d1d: 85 c9 test %ecx,%ecx 107d1f: 0f 84 db 00 00 00 je 107e00 for ( i=len ; i 107d29: 89 7d d0 mov %edi,-0x30(%ebp) width = len; } /* output the string */ for ( i=0 ; i <== NEVER TAKEN 107d33: 8b 55 c0 mov -0x40(%ebp),%edx 107d36: 8a 02 mov (%edx),%al 107d38: 84 c0 test %al,%al 107d3a: 74 1c je 107d58 <== NEVER TAKEN BSP_output_char(*str); 107d3c: 83 ec 0c sub $0xc,%esp 107d3f: 0f be c0 movsbl %al,%eax 107d42: 50 push %eax 107d43: ff 15 a4 a1 11 00 call *0x11a1a4 if (width == 0) { width = len; } /* output the string */ for ( i=0 ; i BSP_output_char(*str); /* trailing spaces */ if ( minus ) 107d58: 8b 45 c8 mov -0x38(%ebp),%eax 107d5b: 85 c0 test %eax,%eax 107d5d: 0f 84 59 fe ff ff je 107bbc for ( i=len ; i <== NEVER TAKEN 107d6c: 89 fb mov %edi,%ebx 107d6e: 66 90 xchg %ax,%ax BSP_output_char(' '); 107d70: 83 ec 0c sub $0xc,%esp 107d73: 6a 20 push $0x20 107d75: ff 15 a4 a1 11 00 call *0x11a1a4 for ( i=0 ; i 107d84: e9 33 fe ff ff jmp 107bbc BSP_output_char(' '); } break; case 'c': BSP_output_char(va_arg(ap, int)); 107d89: 8d 47 04 lea 0x4(%edi),%eax <== NOT EXECUTED 107d8c: 89 45 cc mov %eax,-0x34(%ebp) <== NOT EXECUTED 107d8f: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107d92: 0f be 07 movsbl (%edi),%eax <== NOT EXECUTED 107d95: 50 push %eax <== NOT EXECUTED 107d96: ff 15 a4 a1 11 00 call *0x11a1a4 <== NOT EXECUTED 107d9c: 83 c4 10 add $0x10,%esp <== NOT EXECUTED 107d9f: e9 18 fe ff ff jmp 107bbc <== NOT EXECUTED if ((c = *fmt) == 'l') { lflag = 1; c = *++fmt; } switch (c) { 107da4: 31 c0 xor %eax,%eax 107da6: be 0a 00 00 00 mov $0xa,%esi 107dab: e9 5d fe ff ff jmp 107c0d fmt++; } if ((c = *fmt) == 'l') { lflag = 1; c = *++fmt; 107db0: 8d 51 01 lea 0x1(%ecx),%edx 107db3: 89 55 08 mov %edx,0x8(%ebp) 107db6: 8a 51 01 mov 0x1(%ecx),%dl 107db9: e9 e1 fd ff ff jmp 107b9f 107dbe: 66 90 xchg %ax,%ax lead = '0'; fmt++; } if (*fmt == '-' ) { minus = 1; fmt++; 107dc0: 41 inc %ecx 107dc1: 8a 11 mov (%ecx),%dl 107dc3: c7 45 c8 01 00 00 00 movl $0x1,-0x38(%ebp) } while (*fmt >= '0' && *fmt <= '9' ) { 107dca: 8d 42 d0 lea -0x30(%edx),%eax 107dcd: 3c 09 cmp $0x9,%al 107dcf: 0f 86 a4 fd ff ff jbe 107b79 <== ALWAYS TAKEN 107dd5: 89 4d 08 mov %ecx,0x8(%ebp) 107dd8: 31 db xor %ebx,%ebx 107dda: c7 45 d0 00 00 00 00 movl $0x0,-0x30(%ebp) 107de1: e9 b0 fd ff ff jmp 107b96 107de6: 66 90 xchg %ax,%ax lead = ' '; if (*fmt == '%') { fmt++; if (*fmt == '0' ) { lead = '0'; fmt++; 107de8: 8b 4d 08 mov 0x8(%ebp),%ecx 107deb: 83 c1 02 add $0x2,%ecx 107dee: 8b 45 08 mov 0x8(%ebp),%eax 107df1: 8a 50 02 mov 0x2(%eax),%dl 107df4: c7 45 c4 30 00 00 00 movl $0x30,-0x3c(%ebp) 107dfb: e9 5e fd ff ff jmp 107b5e for ( len=0, s=str ; *s ; len++, s++ ) ; /* leading spaces */ if ( !minus ) for ( i=len ; i <== ALWAYS TAKEN 107e08: 89 fe mov %edi,%esi <== NOT EXECUTED 107e0a: 66 90 xchg %ax,%ax <== NOT EXECUTED BSP_output_char(' '); 107e0c: 83 ec 0c sub $0xc,%esp <== NOT EXECUTED 107e0f: 6a 20 push $0x20 <== NOT EXECUTED 107e11: ff 15 a4 a1 11 00 call *0x11a1a4 <== NOT EXECUTED for ( len=0, s=str ; *s ; len++, s++ ) ; /* leading spaces */ if ( !minus ) for ( i=len ; i <== NOT EXECUTED 107e1f: e9 08 ff ff ff jmp 107d2c <== NOT EXECUTED char *s; str = va_arg(ap, char *); /* calculate length of string */ for ( len=0, s=str ; *s ; len++, s++ ) 107e24: 31 ff xor %edi,%edi <== NOT EXECUTED 107e26: e9 ef fe ff ff jmp 107d1a <== NOT EXECUTED break; case 'c': BSP_output_char(va_arg(ap, int)); break; default: BSP_output_char(c); 107e2b: 31 c0 xor %eax,%eax 107e2d: be 10 00 00 00 mov $0x10,%esi 107e32: e9 d6 fd ff ff jmp 107c0d =============================================================================== 001169a4 : ssize_t write( int fd, const void *buffer, size_t count ) { 1169a4: 55 push %ebp 1169a5: 89 e5 mov %esp,%ebp 1169a7: 56 push %esi 1169a8: 53 push %ebx 1169a9: 8b 55 08 mov 0x8(%ebp),%edx 1169ac: 8b 75 0c mov 0xc(%ebp),%esi 1169af: 8b 4d 10 mov 0x10(%ebp),%ecx ssize_t rc; rtems_libio_t *iop; rtems_libio_check_fd( fd ); 1169b2: 3b 15 40 a0 11 00 cmp 0x11a040,%edx 1169b8: 73 56 jae 116a10 <== NEVER TAKEN iop = rtems_libio_iop( fd ); 1169ba: 8d 04 52 lea (%edx,%edx,2),%eax 1169bd: 8d 04 82 lea (%edx,%eax,4),%eax 1169c0: 8d 1c 85 00 00 00 00 lea 0x0(,%eax,4),%ebx 1169c7: 03 1d d0 e4 11 00 add 0x11e4d0,%ebx rtems_libio_check_is_open( iop ); 1169cd: 8b 43 0c mov 0xc(%ebx),%eax 1169d0: f6 c4 01 test $0x1,%ah 1169d3: 74 3b je 116a10 <== NEVER TAKEN rtems_libio_check_buffer( buffer ); 1169d5: 85 f6 test %esi,%esi 1169d7: 74 5b je 116a34 <== NEVER TAKEN rtems_libio_check_count( count ); 1169d9: 85 c9 test %ecx,%ecx 1169db: 74 27 je 116a04 <== NEVER TAKEN rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF ); 1169dd: a8 04 test $0x4,%al 1169df: 74 2f je 116a10 <== NEVER TAKEN /* * Now process the write() request. */ if ( !iop->handlers->write_h ) 1169e1: 8b 43 30 mov 0x30(%ebx),%eax 1169e4: 8b 40 0c mov 0xc(%eax),%eax 1169e7: 85 c0 test %eax,%eax 1169e9: 74 37 je 116a22 <== NEVER TAKEN rtems_set_errno_and_return_minus_one( ENOTSUP ); rc = (*iop->handlers->write_h)( iop, buffer, count ); 1169eb: 52 push %edx 1169ec: 51 push %ecx 1169ed: 56 push %esi 1169ee: 53 push %ebx 1169ef: ff d0 call *%eax if ( rc > 0 ) 1169f1: 83 c4 10 add $0x10,%esp 1169f4: 85 c0 test %eax,%eax 1169f6: 7e 03 jle 1169fb <== NEVER TAKEN iop->offset += rc; 1169f8: 01 43 08 add %eax,0x8(%ebx) return rc; } 1169fb: 8d 65 f8 lea -0x8(%ebp),%esp 1169fe: 5b pop %ebx 1169ff: 5e pop %esi 116a00: c9 leave 116a01: c3 ret 116a02: 66 90 xchg %ax,%ax 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 ); 116a04: 31 c0 xor %eax,%eax if ( rc > 0 ) iop->offset += rc; return rc; } 116a06: 8d 65 f8 lea -0x8(%ebp),%esp <== NOT EXECUTED 116a09: 5b pop %ebx <== NOT EXECUTED 116a0a: 5e pop %esi <== NOT EXECUTED 116a0b: c9 leave <== NOT EXECUTED 116a0c: c3 ret <== NOT EXECUTED 116a0d: 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 ); rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF ); 116a10: e8 0b 98 ff ff call 110220 <__errno> <== NOT EXECUTED 116a15: c7 00 09 00 00 00 movl $0x9,(%eax) <== NOT EXECUTED 116a1b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 116a20: eb d9 jmp 1169fb <== NOT EXECUTED /* * Now process the write() request. */ if ( !iop->handlers->write_h ) rtems_set_errno_and_return_minus_one( ENOTSUP ); 116a22: e8 f9 97 ff ff call 110220 <__errno> <== NOT EXECUTED 116a27: c7 00 86 00 00 00 movl $0x86,(%eax) <== NOT EXECUTED 116a2d: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 116a32: eb c7 jmp 1169fb <== NOT EXECUTED rtems_libio_t *iop; rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_buffer( buffer ); 116a34: e8 e7 97 ff ff call 110220 <__errno> <== NOT EXECUTED 116a39: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED 116a3f: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED 116a44: eb b5 jmp 1169fb <== NOT EXECUTED